MetaPrompt: a tool for telling yourself what to do.

by abramdemski15 min read16th Mar 202112 comments

63

Quests / Projects Someone Should DoProductivityPractical
Frontpage

MetaPrompt is a nonstandard todo list. The very bare-bones basic idea is that you add ideas to a deck of cards, and you shuffle this deck to draw things to do. This is useful for "tasks" with no priority, where you just want to be reminded of the idea at some point in the future. You can also add cards which tell you to add more cards; hence the name.

Most of this is written in a very narrative way. If you just want the how-to, skip to the how-to section.


For many people, there's something interesting about being told what to do: it's easier to make someone else a sandwich than to make one for yourself, for example. One partial explanation is decision fatigue: deciding to do things for yourself takes some sort of energy, which being told to do doesn't take.

This suggests that, in some situations, people can benefit from 'willpower partners': you each (for example) tell each other to make a sandwich. You end up with two sandwiches and no decision fatigue; a net gain over you each making a sandwich for yourself.

But what if you could be your own "willpower partner"?


In 2016, I was learning dvorak. I wanted typing practice; but, I didn't want boring typing practice. I remembered the post about WriterKata on Agenty Duck from the previous year. WriterKata was a great little website for practicing writing by responding to writing prompts. Why not practice typing and creative writing at the same time, by responding to prompts?

Unfortunately, by 2016, WriterKata no longer existed. It seems the author took the website down. I guess it wasn't worth the hosting expense? (Sad; it seemed good enough that it should have been able to support itself somehow.)

I could have just found writing prompts somewhere and typed my responses into any kind of text file, but I wanted the clean interface: a random prompt selected for me, with a text box directly below it where I could immediately type my response. I know from experience that can be enough to make the difference between vaguely intending to practice for months, vs sitting down and doing it for hours.

I went to the command line. I started a file "kata" for writing prompts, with the idea that I could pull one line from it randomly using standard command line tools. Then, I could write my responses to another file.

However, I was lazy. I didn't want to spend a bunch of time copying writing prompts to the file before beginning.

So, the first line I wrote to kata resembled this (editing for clarity):

Write a new writing prompt to kata with 'echo "prompt" >> kata'.

In other words, my first prompt was create a prompt. This way, I could just keep responding to prompts. Some prompts would tell me to write new prompts (writing to kata). Others would be proper creative writing prompts (writing to a different file, ana). My next four prompts looked like this:

Write a sentence about a stranger on the street.
Write a new sentence kata.
Write a new paragraph kata.
Write a new kata about character creation.

The first one is a regular prompt, but the next three (like the first) are meta-prompts: prompts which tell you to make prompts. Why? Because I realized: if I kept it to only one metaprompt, the frequency of drawing it would be 1/n, where n is the number of prompts. My pool of prompts would grow pretty slowly, and I would see a lot of repeat prompts. Better to have more meta-prompts, growing the pool of prompts more quickly, so that individual prompts wouldn't get too old.

This system seemed to work pretty well. I was inspired to write whatever came to mind, and got some typing practice in. Typing commands like echo all the time was only a little annoying.

I was at the command line, so prompts could tell me to run arbitrary commands. For example, I soon wrote this prompt:

Write a continuation of whatever comes out of 'gshuf -n 1 ana'.

(gshuf -n 1 is how I was sampling random lines from files.) So this one tells me to randomly pick something I had already written, and write a continuation. Unfortunately, there was no link structure: I wasn't connecting bits of text into threads, I was just continuing things I'd written and then dumping the continuations into one big file with no context.

I also created a file called "words", which was just a long list of English words. This could be used in prompts, such as:

Run the command 'gshuf -n 1 words'. Write something using that word.

I started to feel the technical limitations of my approach in other ways. I wanted to create randomized prompts via madlib-style insertion of random words. However, there was no easy way to do this on the command line. Other feature ideas began to swim around in my head as well.

The Vision

I started to fantasize about a website called MetaPrompt, which would streamline what I was doing, add a ton of features, and make the whole thing into an interactive multi-user experience.

  • Unlike a regular writing-prompt website, MetaPrompt allows you to build complex custom structures for accomplishing things. I imagined prompts which would let you build a first draft of a whole novel, piece by piece. I imagined meta-prompts which would guide the user to build their own complex task workflows, asking them to make a list of lofty goals, and then randomly asking them to fill in details of how they would accomplish those goals.
    • (And keep in mind, the state of regular writing-prompt websites is pretty terrible, since the shutdown of WriterKata. So there's not much competition in this sector.)
  • A multi-user experience could be really cool. Mainly, users could share prompt lists, which could be very helpful for getting started with the whole thing. But there is also the potential of users collaborating to write stories. Remember the prompt which asked me to continue one of my own bits of writing? What if you could be asked to continue someone else's writing, too?
    • (Although this introduces a bunch of design questions.)
  • MetaPrompt could also facilitate other things than creative writing. At least, other artsy things, like drawing. (A drawing-based version was ultimately the only multi-user version to see use! So far.)
    • Imagine if you could do technical work this way, randomly dredging up old ideas and being prompted to work on them. No line of thinking would just be forgotten; everything would have its chance of being continued at some point.
    • Imagine if your daily spaced-repetition practice wasn't in Anki, but rather, was interspersed with your regular workflow, because everything is just randomly drawn cards.

I also thought there was a wider space of possible tools in this space: tools which, like MetaPrompt, offer a sort of "user-programmable dialogue". It's like having a conversation with yourself across time. MetaPrompt is in some sense the simplest version of this, where there's no context sensitivity: the next question MetaPrompt asks you has nothing to do with the previous answer. Iirc, LifeLongLearner created some dialogue tools which walk you through CFAR techniques; I'm imagining something similar to that, but where the user can create new dialogue tools through dialogue, rather than just follow someone else's script. This would require some "commands" (ie a simple programming language, not an AI trying to figure out what you mean), but the system would walk you through all of that; the pre-loaded dialogues would teach you everything you needed to know about the system, and these could be invoked again when needed (and possibly recur randomly, for spaced repetition).

The general vision, here, is to remove as much cognitive overhead as possible. No more sitting down and deciding what to do; no more questioning whether you feel motivated/inspired to work on project X. Instead, you sit down to an interactive experience as addictive as facebook, but which puts past you in the driver seat (rather than the facebook algorithm). Even when you do metacognition to figure out new prompts for future you to work on, it's at the behest of a metaprompt. So you never have to wonder what to work on. 

(Of course, you can decide to work on a specific thing rather than what the next random prompt tells you to; for example, when MetaPrompt asks me to come up with something of a given type, I often come up with several ideas, and put them all in. And often when I first sit down for a MetaPrompt session I have several new prompt ideas which I put in before doing anything else.) 

Three Failures

In the years since 2016, I have convinced no less than three separate developers to make prototypes of MetaPrompt for me, all of which have gone unused for one reason or another. The first was an EA who volunteered his time without worrying about business plans or money or any of that, but left the project to work on more effective forms of altruism. The second was my brother, who put together a command-line application (no aspirations of a website for that version), which was pretty capable, but only ever worked on his laptop despite attempts to use cross-platform tools. The third was an experienced developer who cared about business plans, expected market size, and returns on time. I guess that attempt mainly fizzled because I got intimidated and didn't feel like I should bug him about anything, such as adding features I thought were important or taking next steps with respect to the business plan.

(Note that I was pretty busy with other things, and never made MetaPrompt my top, second, or even third priority.)

Success

Late 2019, I wanted to do some kind of art project with friends. We settled on the idea of doing daily comic-strip prompts, in which we would often be asked to continue each other's comics with new panels/pages. My brother created yet another version of MetaPrompt, this time facilitated by TiddlyWiki.

In this version, each day, users are supposed to answer one regular prompt and one metaprompt. This ensured that we had quite a large variety of regular prompts after a while. We stuck with it for several months, and had a lot of fun. (I'm now in a very happy relationship with one of the participants, so that went well..) We did eventually abandon it, for several reasons:

  • Doing a comic page every day is a lot of work, even if you attempt to keep it low-effort and sloppy. Eventually it seemed like too much. We tried to introduce prompts which asked for less work per day, EG separate prompts for scripting a page vs drawing from a script, but by this time we already had a lot of prompts of the higher-effort type; and, I don't think we necessarily came up with great ways of splitting up the work.
  • On the technical side, maintaining the site became a huge chore for my brother. He was our tech guy, and we ran to him with every problem and feature request. Several technical challenges presented themselves over time. The fatal challenge involved storing images efficiently. TiddlyWiki loads everything into memory, so uploading new images to the wiki every day worked fine until it suddenly went past the memory limits on the Amazon server we were using. There are workarounds which let you store images on TiddlyWiki without storing them all in memory, but they're a bit technically involved and took some effort. We ended up losing some of our artwork somehow, which damped enthusiasm.

Overall, I think TiddlyWiki is a great way to set up a MetaPrompt. It's already a capable wiki, so you can link material together, give useful tags, and make use of a wide variety of existing TiddlyWiki plugins. You can easily avoid most of the problems we experienced:

  • If you make your MetaPrompt one-player rather than multi-player, you don't need to worry about maintaining a server; you can just keep it on your computer. This also means you don't have to worry about managing user accounts, setting up passwords to keep the entire internet from inserting spam into your wiki, etc.
  • If you stick with something like creative writing, rather than drawing, you won't need to worry about the memory issues created by images.
  • You can sit down and work in MetaPrompt whenever you feel like it, rather than making it a game where you are required to do 1 prompt per day. This way you don't have to balance the time commitment. (Although if you do go multi-player, I think once-a-day is a nice format; you get to see everyone else's responses, and it provides motivation to sit down and do the thing.)

I currently maintain a personal MetaPrompt tiddlywiki conforming to those three bullet points. Like my original command-line files (the contents of which I've imported), it's for creative writing practice. The next section details how to set one up.

Making Your Own MetaPrompt with TiddlyWiki

You can skip steps 1, 3 and 4 by downloading a blank MetaPrompt TiddlyWiki from my github page. However, I suggest you at least skim the steps so that you know what's basically going on. (Note that my file includes Stroll; you'll have to put it together yourself if you don't want Stroll.)

1: Download a blank TiddlyWiki.

You can download a blank copy of TiddlyWiki from the tiddlywiki home page. Alternatively, if you like Roam, you can use Stroll, a modified version of TiddlyWiki which adds Roam-inspired features. (To download Stroll, look for the "download Stroll" tab on the Stroll webpage. Consider doing the tutorial first, to get familiar with the features and see whether or not you like them.)

I like Stroll, but if you have no experience with TiddlyWiki, I recommend just starting with vanilla TiddlyWiki. Learning TiddlyWiki can be a bit overwhelming in the first place, so you might not want to add Stroll on top of that.

Speaking of -- you might also want to go through some of the tutorial material listed on the TiddlyWiki website. Also, the TiddlyWiki5 Reddit is a helpful place to ask questions.

2: Secure your data with a method of saving.

One peculiarity of TiddlyWiki which you'll have to deal with right away: TiddlyWiki itself cannot save changes long-term. Any changes you make will stick around while you keep the wiki open, but if you close it, they'll be gone. You should fix this before you put any serious work into a wiki.

The TiddlyWiki homepage has plenty of information on this. There are lots of options to choose from -- a dizzying array of them, even. I think the Node.js solution is solid, especially if you might want to serve your TiddlyWiki as a real webpage at some point rather than just on your machine. However, this requires you to run commands on the command line to access your wiki. A "lighter" option is TWCloud. You keep your TiddlyWiki in DropBox (which I do anyway, because I use DropBox to back up everything). When you want to edit it, you visit the TWCloud page and give it permission to access your DropBox. You then navigate to your TiddlyWiki and open it. Definitely not the most secure option, since you have to give an external service permission to read and edit your DropBox. However, it requires no setup and allows you to access your wiki from any computer without having to set up a real website.

There's also a similar service for Google Drive.

3: Install a randomization plugin.

We need a way to select random prompts, and randomize stuff within prompts. One option is the shuffle operator from Matt's plugin library.

Now, randomization in TiddlyWiki is a bit weird. If you just naively use random numbers, you'll run into trouble: the randomness is re-shuffled each time things are re-rendered, which basically means any time you type anywhere in the wiki. This is annoying, and not usually what we want.

Wrangling the randomization to do what you want is probably going to be the most technically involved bit of coding you'll have to do. Unfortunately, I'm not going to go through a whole tutorial here. Instead, I'll just give you some code that works for most purposes. If you're technically inclined, you can probably figure out (with some trouble) what's going on and how to get it to do more. If you're not, you would probably scroll through the tutorial anyway.

4: Make Basic MetaPrompt Tiddlers

"Tiddler" is the TiddlyWiki term for a "page" or "card". The following tiddlers provide the scaffolding for MetaPrompt. Create a new tiddler by pressing the "+" button on the side-bar. This will give you a new page opened in edit mode. 

First Prompt

Title your first tiddler "First Prompt" (or whatever you wish). Tag it "prompt" (this step is important!). The text of this first prompt should be generic instructions to add a new prompt:

Create a new prompt. Don't forget to tag it "prompt" so that the prompt shuffler can find it. (Tag it "prompt" whether or not it is a metaprompt; they're all prompts.)

If you're not sure what prompt to add, think about what your MetaPrompt is currently missing. Are there any things you want to do with your MetaPromt which you're not currently doing? Any type of prompt which you wish was more common? It's OK if your new prompt is just a slight variation of an old one; add a bit of extra inspiration or a slightly different take on the same question.

Remember, you're writing to your future self. You can say anything you want to help orient or inspire future-you. It's good to include reminders such as "don't forget to tag it 'prompt'", to make things as easy as possible on your future self.

You can also add some more specific prompts to start things off.

$:/metap/setcurrentprompt

This tiddler is a bit of code which the prompt randomizer needs. It will not work correctly without it. Make sure the title is as above: $:/metap/setcurrentprompt

Here's what you need to put into the body:

\define weirdaction()
<$action-setfield $tiddler="CurrentPrompt" text={{$(currentTiddler)$}} originaltitle="""$(currentTiddler)$""" />
\end

<<weirdaction>>

Random Prompt

Call this tiddler "Random Prompt" (or any title you wish, really) and paste the following code into its body:

<$button>
<$action-setfield $tiddler="$:/temp/shuffle/randomprompts" $field="state" $value=<<now "0hh:0mm:0ss">>/>
Shuffle
<$list filter="[tag[prompt]] +[shuffle{$:/temp/shuffle/randomprompts!!state}first[1]]" template="$:/metap/setcurrentprompt" />
</$button>

|<$link to={{CurrentPrompt!!originaltitle}} />|
|<$transclude field="text" tiddler="CurrentPrompt" mode="block" />|

This tiddler is going to be our workhorse, which we will return to again and again. We don't want to have to search for it. So, you should add this to the list of default prompts which open whenever you open the wiki. You do this by opening a tiddly called "Control Panel" (which you can find via the search bar, or by clicking the gear icon in the sidebar), and under the "info" tab on that tiddler, modify the "default tiddler" field. Mine looks like this:

I've changed to a dark color scheme; yours will have a light color scheme by default. You can change this in "Appearance". There are also some other fun settings to mess with; explore; make the wiki your own!

Note that Random Prompt has [[double brackets]] around it. This is because the tiddler name contains a space, so it needs to be given with double brackets.

Now everything should be working. You can click the button on Random Prompt to draw a random prompt from your set.

Time to get building.

5: Set Up a System

MetaPrompt is a foundation, but it's not a house. You need to develop your own system of prompts, tags, and so on. This will depend on what you are using MetaPrompt to do. I'll talk about how to set MetaPrompt up for creative writing, since that's what I've done myself.

The "prompt" tag adds a tiddly to the list of prompts, so that Random Prompt can find it and shuffle it into the rest. In a similar way, you probably want to create other tags, so that you can randomly draw things from those groups when you want to. I have tags for characters, settings, and many other objects.

MetaPrompt can facilitate both top-down and bottom-up writing styles. In top-down, first you come up with a basic story idea, then you flesh out the characters, setting, plot, and so on until you have an outline detailed enough that you can write individual scenes. In bottom-up writing, you just write whatever comes to mind and keep moving forward.

I've read that top-down writing is basically a necessity for real authors, because otherwise you get stuck and don't know what to do next.

However, I think bottom-up writing is a better place to start for creative writing in MetaPrompt. I've tried both, and bottom-up writing is just a lot easier. It sets my creative wheels spinning, and generates a lot of ideas which can then be developed in a more top-down way.

So, I have a tag "snippet". A snippet is a tiddler where I write the creative text in the title, and don't even worry about filling in the body. (This somehow feels psychologically important to me -- if I put the text in the body, I'd have to come up with a title. But titling a little snippet of creative writing puts too much pressure on it, to be something meaningful!)

Snippet prompts can be any sort of creative writing prompt, but you're just asking for a sentence or a few. For example:

Write a snippet about someone going somewhere.
Write a snippet in which someone encounters something.
Write a snippet involving sensory descriptions -- sounds, smells, etc.

Once you have a tag, you can draw random members, just like Random Prompt draws random prompts. For example, we can write a prompt asking to continue a snippet:

Write a snippet inspired by the following snippet:

|<$list filter="[tag[snippet]] +[shuffle{$:/temp/shuffle/randomprompts!!state}first[1]]"/>|

(If snippets continue each other, you might want to put links to each other in their bodies, or organize them in some other way. I'm not currently doing this, though, because I'm treating snippets as fodder and keeping more organized stuff elsewhere.)

I also have a 'character' tag, and prompts which ask me to create or elaborate characters. Similarly for 'setting', 'plot', and a few other things.

Here's an example of a prompt which uses characters:

Write a scene in which the following two characters interact. Don't forget to tag it 'scene'.

|<$list filter="[tag[character]] +[shuffle{$:/temp/shuffle/randomprompts!!state}first[1]]"/>|
|<$list filter="[tag[character]] +[shuffle{$:/temp/shuffle/randomprompts!!state}last[1]]"/>|

Note that I use "last" rather than "first" in the second copy of the randomizer. This ensures that the two characters are different. (There's a more subtle problem with the randomization, above, but I leave it to the reader to discover and fix. I don't want to make this post too complicated.)

As you learn more about TiddlyWiki, you'll be able to do increasingly interesting things.

I'm sure my setup for creative writing is far from ideal (which is part of why I've only explained little pieces of it). I would be excited if, one day, there's a whole community of MetaPrompt users who talk about their systems, exchange prompts, and so on.

Limitations / Future Work

  1. This falls short of the basic idea of original MetaPrompt: (A) The system doesn't have a text box directly below the prompt, where you submit your answer by hitting enter. Instead you have to create, name, and save a new prompt. This is unnecessary friction. (B) The system doesn't select a new prompt for you as soon as you submit your answer to the previous prompt. You have to click the "shuffle" button again. This is, again, a bit of unnecessary friction. Shaving off these bits of friction would make the system more engaging.
  2. TiddlyWiki offers a lot of flexibility and power, but due to #1 above and some other reasons, it's in some ways less fun than my original command-line version. In particular, the fact that everything has to have a title field in addition to its body. I worked around this with "snippets" by only using the title field, but it would be nicer to only worry about text + tag, not text + tag + title. This would generally create better flow.
  3. When commanding your future self, it's easy to give yourself a task that's too difficult, which will cause your future self to either click the "shuffle" button again to get something different, or stop using MetaPrompt in frustration. One of my original feature ideas for MetaPrompt was that there would be a "break task into parts" button for the user to hit in such circumstances. This would create a new task for splitting up the task into a list of subtasks (somewhat like factored cognition!), along with a special task for putting the pieces back together once they'd been individually answered. It would be interesting to try and implement something like this (perhaps taking inspiration from tools people have created for facilitating factored cognition).

Some of this could be addressed by hacking TiddlyWiki. I'd love to see people improving the TiddlyWiki version; I think a lot could be possible. On the other hand, TiddlyWiki will always create a certain barrier to entry; it requires figuring out saving, and some scripting to work out stuff like randomization. There's definitely still room to make a more streamlined version of MetaPrompt.

Another thing I'd like to see would be people trying MetaPrompt for something other than creative writing or drawing. Can this apply fruitfully to research? Or other nonfiction intellectual labor? I don't know.

Also note: you can create a perfectly serviceable pen-and-paper MetaPrompt, although it'll be less fully-featured than TiddlyWiki. 

  • Use index cards, blank playing cards, or similar.
  • Rather than using tags to sort objects, you can now keep separate decks for different types of things. When you want a random character, for example, simply shuffle your 'character' deck and pull one out.

I tried this recently and it seemed fine, although I didn't use it for long because TiddlyWiki is just so much more convenient. (However, paper has a big advantage when it comes to drawing, and could even handle painting.)

Footnotes

1:

This is a hyperspace pun. The two hyperspace directions, augmenting 3d-space directions (up, down, north, south, east, and west), have been named ana and kata. I named the prompt file "kata" after WriterKata, so it was only natural to name the response file "ana".

63

12 comments, sorted by Highlighting new comments since Today at 3:32 PM
New Comment

I took a couple hours and hacked together a very simple prototype, just to see how MetaPrompt would play out! Try it out here.

Doesn't support multiple users yet, but it wouldn't be that much harder to build out. Here's the rough source code.

(And since your post led to an implementation of MetaPrompt, that would make your post a... MetaMetaPrompt)

This STRONGLY resembles an old idea of mine that I have, naturally, never actually managed to make - it's called Pique, and it would be a collaborative art-making site, where one person can make an outline, another person can fill in some highlights and shadows, another can add details, etc.

In Pique, you randomly get assigned an unfinished picture and you can draw on it whatever you want, making a fork of it, or you can skip it - the more work has already gone into a picture, the more likely it is to show up (because people would skip it if it seemed low quality), until finally some number of people agree that this version of the artwork (there might be MANY branches, of course) is complete, and it gets added to some kind of archive.

Possibly copies of finished images would be sold, the money split between the company running the site and the users who worked on it, in proportion to how much they added to it. This could also be done with writing, though it would be more difficult and probably involve a lot more factored cognition components, but essentially it's a way to crowdsource art.

Like all my ideas (I am walking feature creep) this ended up becoming an idea for a grand unified system of crowdsourced cognition which would ultimately become a hive mind, and so I've never actually had any idea how to make it. But it resembles MetaPrompt fantastically (and the two could perhaps be merged... maybe as part of that grand unified hive mind... :P)

this ended up becoming an idea for a grand unified system of crowdsourced cognition which would ultimately become a hive mind,

Yep sounds like the same idea ;p

This is really cool! It reminds me a lot of a game we're actually building right now, Storytime. Storytime is a creative-writing game where a group of players are writing a story together, each competing to write the most interesting story continuation in 2 minutes & 280 characters; and you get bonus points for using certain random words, madlib-style.

In Storytime, we have a few default starting prompts (an isekai themed one; a rhyming one; etc) written by hand, One idea we had to increase our pool of prompts was to draw them from responses that our players have created. But maybe an actual meta-prompt, aka having our players explicitly compete to write prompts, would be another way of generating great prompts... Thanks for the idea!

Ah, cool game! Are you familiar with the "story games" genre (EG Fiasco, Apocalypse World, Swords Without Master, Ironsworn, A Quiet Year, Dungeon World, Norwegian Style, Microscope, ...)? I have a weekly story game group; maybe we'll try your game out.

Not super familiar, actually -- we came to this from another direction of gaming (party games, word games like Codenames and Decrypto). Thanks for the recs, though, I'd love to check these out. And definitely LMK if you have any feedback!

I have a Google doc where I write down my business, blog post, and project ideas. I have more than I have time to articulate, and when I get an idea, it just has to come out. So I have to give myself ways to do it where I won't get too perfectionistic, which is why I am trying to shift from writing things into a Google doc rather than into a LW post. I'm also slowly trying to develop some routine formatting processes to help shape the ideas, both so that it's easier to write them and so that I can develop a sort of "brand."

In general, it seems like there's a progression here from the bottleneck being brainstorming, to the idea being prioritization and efficiency. Understanding where your bottleneck is seems like a key piece of self-understanding for productivity purposes.

One could totally add prioritization features to MetaPrompt, eg, putting weights on things to determine frequency of sampling, making it easy to update the weight later (eg you can easily lower the weight of things when they show up, to say "I want to see this less often"), adding spaced rep type formulae to dynamically adjust the weights according to some goals, ...

But yeah, by using metaprompt for creative writing I'm implicitly saying I have particular bottlenecks.

Do you have the code for the failed attempts?

So, my brother's command line attempt that refused to work for me:

https://github.com/dranorter/metaprompt_command

Of the other two, I can probably get you at least the first one if you want access. It's written in ELM.

What operating system do you use?

Mac. I think my brother was using Linux at the time.