Systematizing Implementation Intentions and Trigger-Action Plans in a Getting Things Done (GTD) System; (Also, one-shot habit installation)

[New? Start here: https://meditationstuff.wordpress.com/articles/]

An “implementation intention” is a research construct which was designed to study goal pursuit. (I am told CFAR has adapted this construct to be a practical tool [as has lots of popular advice] and given it the name “trigger-action plan.”)

The idea is that, if you want to make sure you do something, you specify to yourself when or especially where you’re going to do it. Research has shown that, if you specify when and where, you’re significantly more likely to do what you intended, versus the condition where you merely made the intention without specifying when and where.

For example, you might check that you’re holding your car keys in your hand, every time you touch the interior driver’s side door handle, thereby making sure you never lock your keys in your car. (Choosing triggers is an art and a science. I prefer fairly high-level but, importantly, relatively unambiguous triggers, e.g. classes of situations or events. The trigger triggers [sic] as long as it’s ultimately recognizable/graspable-all-at-once by the attentional system.)

(Note that research has shown that the triggered behavior need not be performed mechanically. Research subjects can recall that a particular behavior is available to them but they retain the option to not perform it or to perform a contextually appropriate or creative version of that behavior.)

Again regarding what to call these things, I prefer to just think, “if/when-then-because”.

I think “when-then-because” when I have high confidence that the “when” condition will come to pass. I think “if-then-because” when I’m thinking opportunistically, and I don’t know if the condition will ever come to pass, at least in a form that triggers the “then” clause. [I like having the “if” versions so that I’m decisively prepared when future opportunities present themselves in the environment.] Anyway, let’s simplify it to “if-then-because,” for now; the if/when distinction doesn’t really matter, except that it helps the strategic gears in my brain turn a little better.

The “because” clause is to explicitly, strongly remember why I’m setting this intention, which strengthens the intention, makes its successful formation and triggering more likely, and it also helps me to contextualize, chain, and strategically form and dissolve these intentions. The “because” clause links up the intention with the bigger picture. Often the “because” clause is the very first thing I’ll “capture” (to use GTD language) and then I’ll elaborate or refine it a bit before moving to the “then” clause. The “if” clause is often the last thing that gets specified, though they all influence each other.

So, I have long been interested in forming “swarms,” “suites,” or “chains” of implementation intentions to facilitate achievement of complex goals.

There is some potentially discouraging research that forming implementation intentions makes it less likely you’ll carry out intentions, if the number of intentions set is greater than a handful. My suspicion is that this doesn’t have to be the case and that those results aren’t super-generalizable. If I had to guess, I would expect that the brain can handle many hundreds of them, with training. (I’m sure that the parts of the brain involved in prospective memory would get noticeably bigger over time, like the hippocampi in those London taxi drivers.)

My impression is that CFAR suggests lightweight trigger-action plans, setting them and forgetting them (heh) in the moment. I prefer something slightly more heavyweight (in the practiced limit), and I generally look for ways to systematize behaviors so that I can one-shot install them if at all possible.

So, I’ve been thinking about how to systematize suites of implementation intentions. What I present below could be plugged into an already-existing GTD-style system. (I intend to do just that.)

So, first consider, say, a spreadsheet of implementation intentions that would fill up and evolve slowly over time.

Ok, so, “if-then-because.” That’s three columns:

itb_spreadsheet

(Note that this example isn’t to scale. Each column could have several hundred words, whatever’s needed to sufficiently evoke a complex condition, behavior, or situatedness/bigger-picture context.)

The fourth column is used for linking the intention to a tracking sheet, because I love tracking sheets. I consider the tracking sheet below to be the main “touchstone” or “dashboard.” If you don’t love tracking sheets, just consider this a provocative example that you could adapt.

So, I use generic and tailored tracking sheets because I find them helpful for one-shot installation of habits. If I can figure out how the tracking sheet should look, I’m 95% of the way there towards a regular habit. This one will probably go through more iterations as I play with it:

itb_2015_low_res

(Click graphic to enlarge.)

Alright, so that’s pretty complex. Let me break it down:

  • This sheet can track up to 64 intentions (0-63). Each tiny cell refers to a single intention on a single day. Each column is a particular intention over time. Each row (except for the interspersed informational rows) is a single day.
  • “Sheet code” refers to the id column in the spreadsheet above. It is intended to a be a prefix, e.g. “A” for intention “A1.” All the intentions on this sheet would start with an “A” if that’s what I filled in for the sheet code. There could also be a “B” sheet, etc. An “A” sheet and a “B” sheet could track up to 128 intentions, and so on. We’ll see if I get that far. In any case, I wanted to be able to add in additional intentions up to an arbitrary number. GTD systems sometimes track hundreds of discrete elements.
  • The “Location” cell points back to where the explicit evocations (text) of the intentions are stored, e.g. the name of the electronic spreadsheet or the label on the paper file folder, etc.
  • Each cell contains something like “i > t”. There are three possible letters: i, t, b. And there are two slots, _ > _. This gives six distinct strings that could appear in a cell. i, t, and b stand for, “if,” “then,” and “because,” of course. The idea is that they allow me to quiz myself in a pre-arranged way. (I suppose you could also throw everything in Anki.) “i > t” means that I can look at the “if” clause, and then I have to generate the “then” clause, and so on. These prompts are ordered and staggered to evenly exercise all permutations for a particular intention, over the course of six days.
  • Finally, I creatively repurpose the “i > t” strings to structure my daily tracking; these strings have three symbols for me to color over, the two letters and the angle bracket. I color over the first symbol if that slot/id is currently occupied. I color over the second symbol (“>”) if I got the quiz right and/or it metacognitively feels like the intention is “locked in.” (I could also take the CFAR-style inner simulator view on that, like, simulate the future and ask myself if I’d be surprised if the intention didn’t trigger in the future, etc., etc.) I color over the final symbol if that intention was triggered that day. I may make a hollow circle if the intention could have been triggered but it wasn’t. These notation systems evolve naturally.
  • So those are the big pieces. With a little practice, based on prior related experiments and experiences, I expect to be able to get through this in 5-10 minutes per day, not including curating intentions. But, anyway, we’ll see how it goes. I’ll keep stripping it down until I find the right speed/benefit tradeoff.

In any case, the goal of this system is to have a relatively lightweight (for me) way to signal commitment to myself, to form commitments with myself, and to make it more likely I’ll carry out those commitments when I desire to do so. I’m very curious to see if/how I use this system.

I’m looking for ways to cache dense, sophisticated, opportunistic behavior that importantly do not put a drain on working memory. (And indeed, research shows that the more likely an intention is to be triggered, the less drain on working memory and cognition it has!)

I’m also especially interested in anti-goal-shieldingGoal shielding is often thought to be a positive thing: if you focus on goals over time, to the exclusion of other environmental stimuli and opportunities, then you’ll be more likely to achieve those goals. But that can come at the cost of missed opportunities. It just depends on the specific situation on the ground.

So, one-shot habit installation, sophisticated goal pursuit with reduced drain on working memory and attention (and thereby more flexible attention, for deep focus or open focus), and cached triggers to decisively engage in opportunistic behavior. We’ll see how it goes: about one-in-six of my experiments gets used for weeks (these usually don’t make it to the blog), and about one-in-ten get used for years.

[CLICK to SUPPORT this blog and BUY utterly unique health, fitness, SEX, intimacy, communication stuff.]

Advertisements

One thought on “Systematizing Implementation Intentions and Trigger-Action Plans in a Getting Things Done (GTD) System; (Also, one-shot habit installation)

  1. I think the “because” entry is critical and is what’s missing from most attempts at habit formation. Like, I don’t think I ever forget *about* habits I’m trying to start, I just forget *why* I was so enthusiastic about them. I find it increasingly easy to summon up reasons why they weren’t such a good idea. Priming yourself on the “why” on a continual basis seems like a good way of circumventing that failure mode.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s