►
Description
Presented by Abi Noda, Senior Product Manager at GitHub
A lot of people try to measure developer productivity. But is it actually possible? Abi has spent the past four years figuring out which metrics work and how they can be implemented in teams. In this talk, he’ll share lessons from his journey and a few metrics that can help your team today.
About GitHub Universe:
GitHub Universe is a two-day conference dedicated to the creativity and curiosity of the largest software community in the world. Sessions cover topics from team culture to open source software across industries and technologies.
For more information on GitHub Universe, check the website:
https://githubuniverse.com
A
He
recruited
and
hired
some
great
people
and
the
team
was
happy.
We
had
good
workflows,
we
was
in
github
good
pipelines,
and
so
our
process
felt
efficient
and
we
had
continual
one-on-ones
and
retros.
So
people
were
constantly
getting
feedback
on
how
they
could
improve
so
I'm
pretty
well,
I
felt
pretty
good,
but
after
a
while
something
bothering
me
I
started
feeling
like
we
were
plateauing
I
didn't
know
if
we
were
actually
getting
better.
In
fact,
I
didn't
even
know
if
we
were
good
or
if
I
was
doing
my
job.
A
I
wasn't
the
only
one
interested
in
this
question.
My
boss
was
yes,
everyone
on
the
leadership
team
of
the
company
to
start
reporting
how
they
were
doing
metrics
on
how
they
were
doing
at
our
monthly
meetings,
and
he
specifically
asked
me
to
report
on
an
indicator
of
what
we
were
getting
done.
Our
team's
productivity
or
output
and
I
protested,
I
told
them.
I
had
never
seen
good
metrics
for
doing
this
and
all
the
metrics
that
I
knew
of
simply
weren't
good,
but
it
well
me
I,
don't
care
what
the
metric
is.
A
Why
wasn't
there
a
metric
I
could
use?
Why
didn't
I
have
a
way
of
measuring
how
well
my
team
was
doing,
and
why
hadn't
this
problem
already
been
solved
to
try
and
find
some
answers.
I
reached
out
to
some
mentors
of
mine
and
the
first
person
I
talked
to
was
a
CTO
he'd
been
a
CTO
for
over
20
years,
managed
hundreds
of
engineers
and
now,
when
I
asked
them.
How
do
you
measure
the
productivity
of
your
team?
She
told
me
it
was
impossible.
He
told
me
we
were
actually
flawed
in
even
asking
that
question.
A
I
spoke
to
another
mentor
and
he
told
me
he
was
trying
to
figure
out
how
to
develop
something
like
MBAs
plus-minus,
effectively
a
way
of
measuring
the
value
a
team
member
is
contributing,
but
he
had
no
way
of
figuring
out
how
to
actually
calculate
it.
I
spoke
to
some
other
mentors
and
they
were
all
at
a
lot
also
and
I
couldn't
believe
what
I
was
hearing.
A
A
A
So,
a
few
months
after
I'd
spoken
to
my
mentors
I,
actually
quit
my
job
to
work
on
this
problem.
Full-Time
and
I
quickly
realized
that
metrics
are
a
really
hard
problem.
Of
course
that's
why
they
haven't
been
solved
yet,
and
the
thing
is
that
there
are
so
many
things
in
software
engineering
that
we
can
measure,
but
very
few,
that
I
think
we
should.
A
It
took
me
a
while
to
realize
this
I
spoke
with
many
companies,
read
up
on
all
the
literature
and
looked
at
all
the
products
out
there
and
I
also
spent
a
lot
of
time.
Talking
with
my
dad
see
my
dad
is
a
retired
software
developer
and
if
there's
one
thing
that
developers
and
dads
share
in
common,
it's
that
they
have
a
lot
of
opinions
and
they
like
to
voice
them
and
I'll.
Tell
you
more
about
my
dad
in
a
minute,
so
one
of
the
first
metrics
I
looked
at
was
commits
right.
A
Github
already
had
different
charts
and
graphs
on
commits,
so
it
seemed
like
something
that
was
pretty
easy
to
count.
I
knew
it
wasn't,
gonna,
be
the
perfect
metric,
but
I
thought
hey.
You
know.
Maybe
this
might
be
useful
and
for
starters,
having
no
metrics
is
sort
of
a
red
flag
right
in
software.
We're
constantly
committing
code.
So
if
there
are
no
commits
that
means
no
work
is
getting
done
and
that's
a
problem.
A
This
metric
is
sounding
awesome
already
and
it
gets
even
better.
So
I
spoke
with
a
lot
of
developers
and
teams,
and
we
all
sort
of
agreed
that
in
general,
having
small
frequent
commits
is
better
than
having
infrequent
large
commits
right.
It
means
you're
continually
deploying
changes.
These
changes
are
easier
to
manage,
and
so
with
this
metric,
if
you
increase,
the
number
of
commits
you
have,
you
in
effect,
can
in
effect
are
also
influencing
your
process,
such
that
you
are
committing
smaller
changes
more
frequently
right.
So
this
metric
is
just
sounding
great
I
thought.
A
A
So
if
you
can't
tell
already
my
dad
was
super
sensitive
about
metrics,
so
sensitive
in
fact
that
he
would
blanketly
reject
almost
any
idea.
I
pitched
him
on
in
terms
of
metrics
I'd.
Tell
him
dad
hey
how
about
how
about
this
metric?
How
about
this
one
and
blanketly?
He
would
just
shake
his
head
and
tell
me
that
the
problem
I
was
working
on
was
impossible
and
he
really
he
made
me
feel
like
I
was
speaking
of
evil
or
blasphemous
things.
A
The
tension
between
us
was
rising
and
one
evening
it
erupted.
So
I
was
at
home.
I
was
actually
reading
the
book
accelerate,
which
is
an
awesome
book
that
analyzes
high-performing
teams
and
suggests
some
metrics
that
can
be
used
for
benchmarking.
Your
organization,
anyways
I,
was
reading
this
book
and
some
will
across
well.
A
There
are
a
lot
of
great
ideas
in
that
book,
but
I
was
reading
something
and
thought
it
was
a
great
idea
and
my
dad
I
was
working
at
home
at
my
parents
house
and
my
dad
well
I
think
he
had
been
at
the
grocery
store
and
I
said:
hey
Dad
check
this
thing
out
that
I
just
read
and
again
he
just
shook
his
head
at
me
and
dismissed
me
and
so
I
jut.
It
back
I
said
you
know,
what's
your,
what
are
you
talking
about?
A
My
story
at
the
beginning
of
this
talk
of
not
having
a
way
to
measure
that
was
a
powerful
emotion
and
similarly
for
my
father,
who'd
time
after
time,
two
negative
experiences
with
metrics
his
fear
and
opposition
and
metrics
was
also
really
powerful
and
I
think
this
is
understandable
right.
We
all
know
that
metrics
can
be
used
if
misuse
can
harm
our
culture,
our
processes
and
they
can
make
developers
lives
miserable,
and
it's
not
just
choosing
the
wrong
metrics.
That
does
this.
A
It's
also
how
we
use
metrics
on
our
teams,
so
there
a
lot
of
ways
that
metrics
can
harm
our
teams,
and
one
obvious
example
would
be
if
a
manager
we're
using
a
metric
like
commits
to
reward
or
punish
people
on
their
team
right.
This
is
this
is
not
a
good
practice.
Don't
do
this,
but
less
obvious
ways
in
which
metrics
can
also
harm
our
teams
and,
in
fact,
even
good
metrics
can
be
harmful
when
they're
manifested
or
presented
under
the
exact.
A
So
this
is
one
of
the
features
we
built
in
pole
panda.
It
shows
the
average
code
review
turnaround
time
for
everyone
on
your
team
rank
from
lowest
to
highest
and
I
actually
think
code
review
turnaround.
Time
is
a
great
metric
and
I'll
talk
more
about
it
later,
but
and
just
for
clarity
of
you
turnaround
time
is
the
time
between
someone
on
your
team
requesting
a
review
and
the
reviewer
responding.
A
Thank
you.
So
there
were
a
couple
behaviors
that
I
started,
observing
that
we're
really
interesting.
So
one
thing
that
happened
is
because
teams
started
trying
to
opt
to
turn
around
reviews
more
quickly.
A
lot
of
teams
observe
that
people
weren't
actually
doing
real
reviews.
They
were
just
rubber,
stamping
reviews
in
order
to
get
them
done,
but
the
quality
of
those
reviews
had
really
slipped,
and
this,
of
course,
wasn't
good.
A
Another
really
interesting
consequence
of
this
feature
was
that
the
time
here,
the
calculation
of
the
time
doesn't
include
weekends,
and
so
what
started
end
up
happening
is
that
teams
would
stop
requesting
code
reviews
on
Fridays,
because
they
they
knew
that
it
would
mess
up
their
stats
right,
because
people
won't
be
able
to
get
to
them
until
Monday,
and
so
again
these
these
weird
behaviors
started
occurring
on
teams,
and
it
wasn't
because
this
metric
and
of
itself
is
bad.
It
was
because
of
the
way
they
were
presented
and
manifested
in
pull
panda.
A
So
we've
looked
at
a
couple
ways:
metrics
can
backfire,
and
this
is
really
important
because,
again
to
be
successful,
you
not
only
have
to
choose
the
right
metrics
and
measure
the
right
things,
but
you
also
have
to
design
the
way
you
present
metrics
in
the
right
ways.
A
moment
ago,
I
talked
about
how
commits
is
a
problematic
metric,
and
but
it's
not
the
only
one
that
spells
trouble.
A
I
think
there
are
five
common
metrics
that
I
see
companies
using
all
the
time
as
a
way
of
measuring
output
or
product
and
I
call
these
the
flawed
five
in
a
moment,
I'll
walk
through
these,
but
first
I've
said
the
word
productivity.
Throughout
this
talk,
but
I
haven't,
we
haven't
really
defined
what
it
means
in
the
context
of
software
engineering
and
I
have
a
funny
story
about
this.
A
I
you
know
spends
a
lot
of
time
pondering
this
question
and
a
few
months
ago,
I
was
in
a
meeting
and
I
asked
everyone
in
the
room
to
share
their
definition
of
what
productivity
met.
One
person
raised
their
hand
and
suggested
that
it
be
measured
similar
to
GDP.
In
other
words,
maybe
the
profit
or
yield
per
engineer
in
a
company
and
I
thought
to
myself.
A
You
know
that's
interesting,
but
it
sounds
kind
of
agricultural
we're
not
building
farms
here
we're
building
software
and
after
this
meeting
I
kept
thinking
about
this
and
when
I
went
home,
that
night
I,
actually
just
googled
the
definition
of
productivity
and
funny
that
the
definition
that
came
up
was
the
state
or
quality
of
producing
something,
especially
crops.
I
thought
this
was
really
funny.
A
I
guess
that
person
was
spot
on
and,
of
course
it
left
me
even
more
confused
about
you
know
what
what
the
correct
definition
of
productivity
is
in
software
development
and
I've
asked
many
developers
and
leaders.
This
question
and
I
get
all
kinds
of
different
responses,
but
by
far
the
most
common
response
I
get
is,
is
how
much
are
we
getting
done
right
output
and
this
makes
sense
because,
after
all
in
software
development,
we
produce
things,
and
so
it's
a
lot
cool.
We
want
to
measure
how
much
we're
producing.
A
A
We
all
know
that
even
really
small
changes
in
terms
of
lines
of
code
right
can
take
an
immense
amount
of
time
and
effort
to
figure
out.
So
in
software
we
can't
really
measure
output,
but
unfortunately
that
doesn't
stop
people
from
trying
and
those
flawed
five
metrics
I
referred
to
earlier
earlier.
That's
what
they
all
share
in
common
they're,
all
metrics
that
are
used
to
try
to
measure
output,
to
try
to
measure
productivity
and
they
don't
work
so
we'll
go
through
them.
So
number
of
lines
of
code
is
a
metric.
A
That's
been
around
ever
since
people
started
writing
software
and
it's
a
really
bad
measure
of
productivity
right
for
starters,
there's
different
languages,
different
formatting
conventions.
So
you
know
three
lines
of
code
and
one
language
might
be
tens
of
code
in
another.
So
it's
really
difficult
to
even
compare
on
top
of
the
I.
Think
any
good
software
developer
knows
that
one
year,
refactoring
code
or
writing
good
code.
A
What
you're
actually
trying
to
do
is
create
less
code
right,
and
so,
when
you
use
lines
of
code
as
a
metric
as
a
way
of
measuring
output
or
productivity,
you
actually
incentivize
the
opposite
of
opposite
programming,
practices
and
behaviors.
We
want
to
build
good.
Software,
unfortunately,
is
still
a
really
common
metric.
It's
used
many
different
companies
in
our
industry.
In
fact,
you
know.
Just
a
couple
months
ago,
I
came
across
a
company
that
was
stack,
ranking
developers
based
on
a
number
of
lines
of
code.
A
They
wrote
and
actually
firing
people
who
ranked
low
and
I
think
we
all
in
this
room
recognize
that
that's
a
terrible
practice
but
needs
to
stop.
But
again
it's
it's
surprising
and
how
common
the
still
is
in
our
industry,
and
we
need
to
move
away
from
this
another
metric
I
see
that's
more
recent
being
used
to
measure
productivity
is
poor,
request,
count
and
Counting
pull
requests
seem
to
be
a
recent
trend.
I
was
a
meet
up.
I
was
at
a
meet-up
last
year,
and
a
manager
told
me
I
think
poor
request.
A
Con
is
the
new
vanity
metric
and
I
completely
agree
with
them.
Counting
poor
request
is
a
vanity
metric
right.
It
doesn't
take
into
account
the
size
or
difficulty
of
those
pull
requests
and
really
a
day.
All
it
tells
you
is
just
how
many
pull
requests
were
created
so
like
lines
of
code,
this
metric
can
encourage
actually
negative
behaviors
on
your
team
right.
A
A
So
another
one
is
velocity
points
and
I.
Think
velocity
points
can
be
an
unpleasant
subject.
I
think
a
lot
of
developers
just
see
them
as
a
necessary
evil.
I'm.
Personally,
a
big
fan
of
velocity
points.
I
think
that,
when
used
as
designed,
there
are
a
fantastic
estimation
tool
and
something
you
can
use
to
forecast
delivery
on
your
team,
I
think
you
run
into
problems,
though,
when
try
to
turn
velocity
from
forecasting
and
estimation
tool
into
a
measure
of
productivity
or
output.
When
you
reward
people
or
teams
based
on
the
number
of
points
they're
delivering.
A
This
immediately
jeopardizes
the
accuracy
of
the
estimates
they
provide
because
they're
incentivized,
who
inflate
the
number
of
points
things
take
just
inflate
the
number
of
points
they
deliver
and
when
this
happens,
velocity
points
ends
up
just
being
a
meaningless
metric.
So
as
you
soon
as
you
take
in
velocity
points
and
start
using
it
as
a
measure
of
output
or
productivity,
it
becomes
useless
for
its
actual
design
purpose.
A
So,
finally,
there's
a
new
metric
that
it's
a
new
proprietary
metric,
that
a
lot
of
the
leading
vendors
providing
engineering
analytics
tools
have
built
into
their
products,
and
it's
called
impact
for
those
of
you
who
aren't
familiar
with
it.
Impact
is
essentially
lines
of
code,
but
it
also
factors
and
other
things
like
how
many
different
files
were
touched
or
and
and
one
amount
of
code
that
was
change,
was
new
versus
existing
code
and
all
these
factors
are
combined
to
create
what
is
called
an
impact
score.
A
I've
observed
many
companies
that
have
tried
to
use
this
metric
and
in
almost
all
cases,
developers
have
hated
right,
and
not
only
does
this
metric
suffer
from
the
same
flaws
as
lines
of
code,
but
it's
also
really
difficult
to
understand.
There's
so
many
things
that
go
into
calculating
this,
that
it
becomes
a
national
and,
lastly,
I
think,
is
a
problem
with
the
naming
of
this
metric
by
calling
it
impact.
A
So
just
to
recap,
these
are
the
flawed
five
metrics
and
all
these
metrics
are
ways
that
I
see
companies
trying
to
measure
output
in
order
to
measure
productivity
and
they
don't
work
right,
they're,
not
accurate,
then
some
incentivize,
negative
Baker's
on
teams
and
as
I've
done
research
on
this
one
question
I've
had.
Is
you
know?
Why
is
it
that
so
many
companies,
so
many
people
use
these
metrics
despite
their
flaws?
Why
is
it
you
know?
Why
does
this
keep
happening?
A
I've
met
with
leaders
who
are
in
charge
of
thousands
of
engineers,
and
they
have
absolutely
no
idea
what's
going
on,
let
alone
how
well
they're
doing
I've
spoken
with
open-source
maintainer
projects
in
the
world
with
no
idea
whether
their
communities
are
healthy,
whether
they're
growing
or
what
the
impact
of
their
projects
even
are,
and
these
are
all
scenarios
where
measurement
would
be
incredibly
useful,
but
where,
today,
there
aren't
really
good
ways
of
doing
so
and
I
think
it's
this.
This
burning
desire,
this
desperation.
A
That
leads
us
into
the
up
measuring
the
wrong
things
or
using
metrics
in
the
wrong
ways,
even
even
when
we
see
the
flaws
so
to
help
prevent
dubs
from
falling
into
these
traps,
I
think
we
need
to
better
understand
ourselves.
We
really
need
to
understand
why
we
want
to
measure
and
this.
Why
is
really
important,
I
think
understanding
this?
Why
helps
us
recognize
our
own
biases
and
avoid
the
traps
that
I've
talked
about?
I
think
that
in
almost
all
cases,
our
desire
to
measure
falls
into
four
for
reasons
and
I'll
go
through
them.
A
Think
the
first
and
obvious
reason
we
want
to
measure
is
to
prompt
action
or
inform
our
decisions.
I
was
talking
with
an
engineering
manager
who
was
really
confused
being
distributed
and
on
their
team
in
uneven
ways,
and
so
what
he
wanted
was
some
sort
of
ode.
How
many
reviews
everyone
on
the
team
had
a
signs
in
real-time
so
that
their
team
could
use
that
to
determine
who
should
get
the
next
code
review?
A
There
are
lots
of
different
cases
like
this,
for
example,
maybe
an
open
source
I
talked
to
a
lot
of
maintainer
x',
who
just
want
a
way
to
quickly
diagnose.
You
know
what
are
open
things
that
haven't
been
responded
to
or
work
that's
gone
stale
then
to
be
followed
up
on
and
so
again
very
common
cases.
Just
you
know
what
do
I
need
to
do
another.
Another
reason,
I
see
is
that
you
know
all
organizations.
All
teams
need
some
way
of
creating
alignment
for
determing.
A
What
is
it
we're
trying
to
do,
and
how
can
we
measure
whether
we're
actually
doing
it
right
so
I'm
sure
I'll
and
all
your
team's
you're,
familiar
with
things
like
ok,
ours
and
really,
when
you're
setting
goals
and
doing
something
like
ok,
ours
right?
You
need
some
way
to
actually
come
on
by
and
it's
quantitatively
expressed
your
goal
and
verify
that
you're
actually
achieving
it.
And
this
is
another
common
use
case.
I
see
for
Y
teams
and
executives
and
developers
want
to
measure.
A
A
He
was
asking
the
board
for
10
million
dollars,
a
10
million
dollar
investment
in
his
organization
to
increase
headcount
and
procure
some
new
tools
and
to
ask
for
this
he
had
to
be
able
to
actually
show
that
this
investment
would
improve
their
organization
right
and
I
think
this
happens
all
the
time,
even
as
a
myself
as
a
manager
when
I
went
to
my
boss
and
ask
for
more
budget
to
hire
I
needed.
Something
to
be
able
to
point
to
to
justify
this
additional
investment.
A
Companies
ask
us
all
the
time
you
know
show
us
how
github
is
improving
our
organization
and
in
those
conversations
today
into
many
of
the
similar
problems,
where
we
see
companies
creating
all
kinds
of
different
numbers
and
metrics.
That
oftentimes
don't
mean
a
lot
in
order
to
justify
their
investment,
increases
investment
in
github.
A
Lastly,
all
of
us
in
the
work
we
do,
we
all
we
all
aspire
to
have
a
higher
purpose
and
what
we're
doing
we
all
want
to
understand.
What
is
the
impact
that
at
work
is
actually
having
on
the
world,
and
this
is
a
theme
that
comes
up
most
when
I
talk
to
open
source
developers
who
are
investing
all
this
time
into
their
projects
into
their
communities.
A
Yet
they
don't
really
know
whether
all
this
work,
you
know
what
it's
going
for
and
I
think
this
is
also
true
for
us,
as
individual
software
developers
or
for
those
of
us
who
lead
teams.
We
want
to
feel
good
about
the
work
we
do
and
to
do
that,
we
really
need
to
understand.
You
know
what
is
the
value
we're
delivering
at
the
end
of
the
day
and
again,
this
is
this
is
so
higher
purpose
is
another
reason
why
I
think
we
all
want
to
be
able
to
measure
things.
A
So
I've
talked
a
lot
about
the
flawed
five
metrics
that
don't
work.
My
father
was
fearful
and
opposed
to
any
metrics,
but
I
do
want
to
share
some
hope.
I
do
want
to
talk
about
some
ways.
I
found
some
cases
where
I
found
metrics
do
I
can
provide
value
to
your
teams.
I
think
there
are
really
three
poor
as
to
making
metrics
work
on
your
team.
A
So
when
people
ask
me,
you
know
how
do
you
measure
productivity?
How
do
you
measure
performance
of
a
engineering
organization,
the
question
I
ask
them
is
well.
What
does
a
high-performing
organization
even
look
like
right?
What
does
it
mean
to
be
productive
and
I?
Think
what
we
know
it
doesn't
mean
what,
when
you
picture
a
high-performing
organization,
I,
don't
think
what
we
picture
is
an
organization,
that's
writing,
menu
lines
of
code
or
creating
many
pull
requests
or
has
a
high
velocity
column
right,
I.
A
Think
when
you
think
of
a
productive
organization,
what
I
picture
is
a
team
that
is
being
responsive
to
one
other.
That
is
collaborating
efficiently
right.
That
has
really
efficient
process,
and
this
is
the
response
I
give
to
people
I
ask
this
question:
I
tell
them
that
you
know
when
we
really
want
to
measure
productivity.
A
But-
and
these
are
some
examples
of
process,
metrics
I
think
what's
really
cool
about
process.
Metrics
is
that
as
developers
we
really
care
about
this
stuff.
These
are
all
things
that
directly
impact
the
day
to
day
developer
experience
and
when
we
measure
these
things,
we
not
only
improve
the
experience
for
developers,
but
we
also
have
concrete
numbers
that
we
can
use
the
show
that
our
organizations
are
improving,
so
I
think
measuring
process
is
the
best
thing
we
can
measure
today
to
measure
and
increase
productivity.
A
A
So
number
two
on
the
list
was
to
measure
against
art
versus
absolutes.
This
is
this
is
a
chart
from
poll
Panda.
It
shows
the
average
well,
it
shows
a
breakdown
of
code
review
turnaround
times
on
a
team
and
when
I
found
with
a
lot
of
process
metrics
is
that
it's
interesting
to
be
able
to
see.
You
know
what
your
average
code
review
turnaround
time
is
or
how
it's
trending
that's
interesting
to
see,
but
it's
really
not
that
useful
and,
as
I
showed
earlier
with
that
leaderboard
right,
it
can
also
incentivize
negative
behaviors
I.
A
Think
that
a
better
approach
is
to
measure
all
these
metrics
against
targets
that
you
define
right.
No
two
teams
are
the
same
even
within
an
organization
and
so
I
think.
The
best
approach
for
using
these
metrics
is
to
allow
every
team
in
an
organization
to
define
a
target.
So
in
this
example,
this
is
saying
you
know:
team
is
setting
a
goal
of
24
hours
as
their
goal
for
code
review
turnaround
time
and
then,
instead
of
measuring
just
what
the
average
time
for
code
reviews
is.
What
you're
measuring
is
what
is
our
success
against
the
goal?
A
We've
defined
right
so
I
think
this
is
a
much
more
useful
way
of
using
these
metrics.
It
also
prevents
those
negative
behaviors.
We
looked
at
and
I
think
this
metric
is
also
useful
for
cricketer
and
managers,
because
they
provide
really
simple
snapshot
and
to
how
your
team
is
doing
and
not
measured
by
interpretation
of
you
know
whether
a
number
to
be
higher
or
lower
right,
but
what
this
numbers
house.you
is.
A
How
is
how
the
team
doing
against
the
gold
vase
at
and
the
final
piece
is
going
back
to
what
we
talked
about
earlier
I've,
seen
almost
no
cases
where
measuring
individual
developer
stats
and
showing
a
historic
historical
number
for
individual
developer
stats
is
beneficial
or
at
least
beneficial
enough
to
counteract
the
negative
behaviors
and
they
can
introduce
on
our
team.
I
found
that
just
the
mere
presence
of
individual
metrics
can
influence
teams
negatively
in
powerful
ways.