# Inversive Management

Source: https://www.yegor256.com/2019/07/10/inversive-management.html

If you are a [manager]({% pst 2016/may/2016-05-24-who-is-project-manager %})
in a software team, your job
is to make your people get things done. This is obvious. The question though is
how exactly you make it happen. How do you make them do what _you_ want, according
to _your_ plans, achieving _your_ objectives, to _your_ quality standards,
and within the borders of _your_ requirements and expectations? Some of you
may say that these are _our_ objectives, _our_ mutual plans, _our_ quality
standards, and _our_ requirements. This may be true, but initially they are still only yours.
How do you make them theirs? There are two ways: a traditional one and an _inversive_
one.


{% jb_picture_body %}

Here is how it works, over and over again. First you hire them, and all of them are experts.
Well, most of them. At least this is what their resumes say. Then you sit together and define a plan.
It looks doable and you [trust]({% pst 2019/may/2019-05-28-trust-or-not %}) them.
They start working and soon enough you realize that some of them
are lagging behind the promises made in the plan. You start ~~begging~~ asking them
to correct, to improve, to be more effective, to be more responsive,
to commit, and to stay focused. You may even hire an Agile coach to train them.
They improve, but not for long.

{% quote Bad managers, together with Peter Drucker, believe that management is art %}

You have "to stay on top of things" and never miss anything, if you want the project to succeed.
You have to _care_. You have to be in the office all the time.
You know, from your experience, that without your permanent attention
people don't do what they are supposed to do. Eventually you start believing,
together with [Peter Drucker](https://en.wikipedia.org/wiki/Peter_Drucker),
that "management is art" since you never know exactly how you have to
[support]({% pst 2016/jan/2016-01-05-how-to-punish-employees %}) each of them,
because every person is a Universe and must be taken care of, individually.

This is traditional management and it's all about _you_.
You have to _care_, you have to _worry_, you have to _be there_ to make
things happen, and you have to _chase_ them. You _need_ their results
and they may provide them... if they feel like it. If you don't
_collect_ the results, you most probably won't get anything, or very little.

There is, however, a better alternative, which looks
like _inversive management_ to me. Here is a practical example. I hired
a researcher a few days ago. She was supposed to find and build me a list
of the most influential Twitter accounts of tech journalists. Here is how
she suggested I structure our contract: "You pay me $5 per hour."
This would be traditional management. She works and I
chase her, asking how is it going, is it a good quality list, is it big
enough, are there any problems with finding the right people, and so on.
I would have to worry about this small project.

Here is what I suggested instead: "I pay you $40 when the list is complete."
Now she has to chase me, to deliver the list to me and to collect the payment.
She has to convince me that the list is good, long enough, and of
good quality. She has to worry about the deadline, about the requirements,
and about all the other problems related to the work. They're all her troubles.

I made her chase me.

This, I believe, is the cure for all management problems:
**make them chase you**.

How do you do that? Just like I did---you turn yourself into a _buyer_
making them be _sellers_ of their results. You've got the resources (money), which
you are ready to release if your people provide you what you need. Obviously,
you don't need them [_to work_]({% pst 2015/jul/2015-07-21-hourly-pay-modern-slavery %}),
you need their _results_, such as a list of emails, a new
feature, a bug fix, a new document, or maybe a new UI mock-up.

{% quote This is the cure for all management problems: make them chase you %}

You, as a pragmatic and smart project manager, define what the project
needs from its participants, you put a _price tag_ on each need, and let programmers
worry about how they deliver, how they solve their own problems, and
how to convince you that their results are good enough to be paid for.

Of course, it's easy to put a price tag on a simple gig, like building
a list of Twitter accounts. It's much
more difficult to do the same for a complex task, like writing source
code or administering a database. However, if you don't do it,
you will be [managed]({% pst 2017/aug/2017-08-01-how-to-manage-a-manager %})
by your programmers, not the other way around. You will
have to constantly chase them and literally beg for results. They will
be relaxed, you will be worried. They will get paid, you will be
[punished]({% pst 2019/jun/2019-06-19-how-much-they-suffer %})
for their mistakes.

I suggest you _invert_ the situation and let _them_ worry.