“Just try it”? How NOT to sell a controversial idea

Alas: when it comes to pitching a controversial idea, many of us in technology fail miserably. We often fall reflexively into extreme “oversalesmanship” of a pet idea. We tend towards the binary: we seem to find it next to impossible to see the idea’s downsides, or to imagine how other people might be viewing it and how we could usefully, effectively, and without condescension counter their various objections (i.e., barriers to the “sale”) of our idea. 

Instead, here’s how we often react. We “flip the bozo bitall too readily on anyone who criticizes our baby: such folks are clearly clueless, we think; we rant that they must not be technical; they’ve “probably never written software at all” and “possibly can’t work their <expletive> email; they’re a PHB; they’re a troll; they’re a dinosaur; we can’t wait for them to die out so we, the enlightened wizards, can take over. (Actual examples of such declarations are easy to find).

None of this attitude is inevitable or unfixable. A start at combating this weakness when selling others on a controversial idea is to heighten our own awareness of the problem. Inspect and adapt, after all. So let’s focus here on one particular tactic of such bad salesmanship, as frequently employed by the (yes, very controversial) #NoEstimates movement: the “just try it” taunt.

Specifically, one of the relatively more polite jibes from the #NoEstimates movement at their critics is the constant objection that the critics haven’t themselves tried NoEstimates, so how could they possibly dare to venture an opinion on it. “Just try it”, the NE proponents insist, and they thereby somehow imagine triumphantly that they’ve dropped the mic. Examples:

“Just try it” is both a poor suggestion and not an argument 

Here’s the way I look at it, and this post will explain why: the incessant NE catcall of “just try it” actually deserves not just to be criticized, but to be rejected soundly; it simply makes no sense. And it reveals much about the NoEstimates mindset: chiefly, that they haven’t thought a whole lot through. 

Let’s think about some objections that come immediately to mind when I’m told I should “just try” NoEstimates.

  • It’s unclear what “trying it” even means, because as I’ve often pointed out, NoEstimates advocates steadfastly refuse to clearly define what their movement actually recommends/stands for. 
  • “Trying it”, for any definition of NoEstimates, isn’t a mere personal choice. You can’t just “go it alone” on trying NoEstimates and then come to your own conclusions, with no involvement from or effect on other people. 

“Just try it” in the case of NE, in fact, really means “impose some (ill-defined, vague) new approach on the entire team, for a non-trivial amount of time, as its new approach to building software.” And (unless you’re simply dictating to the team what it has to do), when we try something like that for an entire team for a good length of time, it first needs to pass the “red face test: the approach must be justifiable up front, using a solid reasoned argument, one that is plausible both to the team and to your management chain. There are needs and impacts at business scale that take such an experiment far beyond being a purely individual trial. You need to have people bought into the idea, or the whole experiment will be useless anyway. And from a business perspective, you also need to be able to minimize, or at least accommodate, any associated ripples or side-effects. When the CEO asks about your team’s plans and progress, it won’t be an acceptable answer to tell her, “oh, this quarter we’re experimenting with not thinking at all about that.”

No compelling case

So, NoEstimates’ catcall of “just try it” doesn’t make logical sense for the above reasons, but there’s more (or, I suppose, less): the taunt, even after six years of Twitter tempest, also hasn’t ever been backed up with a presentation of a compelling case for NE and/or the addressing of the counterpoints that critics have raised.

It shouldn’t be hard to intuitively grasp the following: “just try it” makes zero sense in general, if you don’t present a reasoned and compelling rationale for WHY people should try the thing you’re proposing. For example,

  • I haven’t “just tried” driving with my eyes closed.
  • I haven’t “just tried” having my team code outside in a rainstorm.
  • I haven’t “just tried” having my team do all their work with classical music blaring at maximum volume.

Let’s recap some of the above: “just trying” NE isn’t like trying a new kind of mayo for your sandwich. It’s way more than just a personal quick experiment; it affects others, and as such it merits a reasonable amount of forethought versus just whimsy. In short, EACH ONE of the three words in “just try it” is problematic when applied to a team approach such as NoEstimates: 

  • “just”, which trivializes the duration needed for the experiment, dismisses the need for getting buy-in to your compelling reasons for doing it at all, plus ignores the possibility of negative side-effects;
  • “try”, which makes it sound like a quick look-see, rather than a lengthy and team-wide effort; and 
  • “it”, which NoEstimates has quite intentionally left undefined; they even proudly pitch NE as entailing a potentially different approach by every proponent.

We actually have alternatives to “just trying it”. Thankfully. 

We can and do evaluate all sorts of ideas without having to actually try each one. In fact, we do that all the time, in daily life and in business: we don’t ourselves try everything that comes to mind, or everything that anyone happens to propose or evangelize. It’s natural and healthy to winnow down what you’ll invest time, money, and energy into trying.

Unsurprisingly, we’re not inclined to try an idea that strikes us as entailing high risk, resulting in low payoff, or having little compelling argument for its adoption, no matter how strongly someone pushes such an idea at us. It’s even possible (indeed, common) to adopt a very strong stance against a clearly bad idea without having actually tried it, and it’s easy to think of examples: activities like doing crystal meth, hitchhiking, bike riding without a helmet, staring at the sun during a solar eclipse, spanking children. I don’t need (or desire) practical experience in any of those to oppose them.

“Just try it”, as commonly used by NoEstimates proponents in the example tweets, is the attitude of the salesman (come on, just try it), the zealot (it always works if you just do it right), and the playground taunter (what are ya, CHICKEN?), all rolled into one. It’s definitely NOT the attitude of anyone who understands that there may be pros and cons to the proposed idea, and who is willing to soberly discuss them with those who may be hesitant.

#NoVersionControl: a Modest Proposal

Let’s further illustrate the magnitude of the NoEstimates “just try it” disconnect, by concocting an extended analogy from the software development world that demonstrates why “just try it” is such a poor approach to convincing anyone of something as problematic as dispensing with estimates: let’s hypothesize an advocacy group for eliminating the use of software version control. Let’s be clear: I myself happen to greatly value using robust version control in software development. And indeed, most people with much experience in software development feel the same way. 

But bear with me, and keep in mind that this is just an analogy: let’s imagine for a moment that a group of folks pops up on Twitter and elsewhere, espousing a #NoVersionControl movement. They write blog posts and deliver conference talks, insisting they work fine without version control, and that in fact “all that time you spent on version control could have been doing real work” instead. And they even use words like “eviland “suicidaland “mentally deranged” to describe version control. Their main argument appears to consist of repeatedly stating dramatic things like “git makes you cry.” They revel in telling horror stories about hapless individuals who have erased or corrupted their entire code repository with a single errant git command. Maybe they even regularly post cartoons depicting bad git experiences. They routinely declare that “there are better ways” than traditional version control, but remain quite vague about what those better ways are. They also demand that anyone questioning them needs to “prove” that doing version control is actually worth the time and effort.

Imagine further that these #NoVersionControl advocates react very badly to questions and criticism. Say that they routinely refer to their critics as trolls, morons, dinosaurs, and worse, even using profanities. They block their critics, and encourage others to block them too, and proudly describe doing so as “filtering out the noise”. They refuse to answer direct questions about their stance, and they retort that those who question their stance simply “aren’t ready for the conversation”.

More oddities, perhaps, about these imaginary #NoVersionControl advocates: say that they assert they can’t possibly discuss the topic on Twitter, while nevertheless tweeting tens of thousands of times favoring the idea. They insist that only one-on-one conversations on the topic will suffice, to truly impart their #NoVersionControl wisdom. And maybe several of them travel the world giving paid workshops on #NoVersionControl, all the while innocently maintaining, “I’m not trying to convince anyone.”

Picture everyone’s confusion when these hypothetical #NoVersionControl folks also frequently aver, “I’m not saying never use version control.” (In the next breath, maybe they often boast that they haven’t used it in more than 8 years). And despite reiterating that they’re not advocating “never use version control”, they refuse to name situations when version control would indeed be suitable. And, of course, one of their go-to arguments is that people should “just try” going without it.

Drop the mic, for realz

So, seeing all the attitudes and behavior described above, and having heard no compelling arguments that would cause me to reject version control as a generally wise practice (not to mention that I can easily envision some very real dangers of not having my code under version control!), why would I possibly “just try” #NoVersionControl? Why would I be so inclined, given the poor arguments (and even worse behavior) shown by the #NoVersionControl advocates?

Now, extrapolate all that to NoEstimates; doing so shouldn’t take long (unless you start clicking on some of the links to NE statements that I’ve helpfully included in the analogy). “Just try it”? I don’t think so.

And by the way, if you’re reading this as a NoEstimates advocate and thinking that my concocted #NoVersionControl is an utterly outrageous comparison, and that of course no one in their right mind would oppose version control: well, maybe think a bit more about the implications of that reaction.

Bottom line

Reality: in the business world, basically no one tries anything non-trivial without assessing (and needing to justify to others) the likely merits of what they’re trying. We don’t “go it alone”, and we shouldn’t. No one has unlimited budget (either mental or financial or time available) for experimenting in all dimensions and areas, particularly with company money and an ever-present and understandable scrutiny on how company funds are spent. We all pick and choose what we’ll champion and what we’ll experiment with, selecting from the superset of possibilities, intentionally leaving some paths unexplored. We all use our judgment to make that selection. And we all should be able to soberly describe the specific reasons and criteria for our choices, and be able to convince others that our experiments are justified.

So, you want me to “just try” some specific new approach? Then convince me why I should. (And no, that’s not a demand for “proof”, it’s an utterly natural and human request that you actually present a reasonable case that I should try the technique you are proposing).

  • Describe to me in detail how it worked for you, AND where it didn’t, or where it wasn’t ideal. 
  • Think about how generalizable your approach actually is. Put yourself in others’ shoes. Prepare civil, comprehensive, non-dismissive answers for our likely objections.
  • Stop thinking that the more vigorously and vehemently you evangelize your approach, the more convincing your pitch will be. Because it’s probably just the opposite. 
  • And maybe hold back on hurling insults like “scary” or “you don’t know what you’re talking about at people who still won’t try what you’re so avid about, because all that shows is that you haven’t convinced them that it’s worth their time, money, energy, and reputational investment. In other words, the gap is your problem, not theirs. And if you arrogantly posture as if their reluctance is their problem, they’ll be even less likely to give your idea any credence.

And especially, show some basic business savvy: don’t tell me, when your proposal involves a major SDLC-impacting shift in approach, that I should “just try it,” because that just shows you don’t realize or care that “trying it” is far wider in scope, company impact, employee buy-in, and personal responsibility than trying a different kind of mayo on my sandwich.

When you fail to take into account people’s natural concerns and objections about your new idea, you come off as just plain arrogant. Your evangelistic urge has clearly pushed aside your critical thinking and empathy. And that will drastically reduce the odds of people taking you seriously on this or maybe much else.

Speak Your Mind


This site uses Akismet to reduce spam. Learn how your comment data is processed.