I have a problem, and you probably do to: I call it project incompletionism. A tendency to start more projects than we can finish.

Seth Godin calls it The Dip. Stephen Pressfield calls it The Resistance. But it all points to one simple fact: Starting a new project is more fun than finishing one.

I often have 5, 10, even 20 different projects I’m working on all at once. It’s absurd!

David Allen, creator of Getting Things Done, calls incomplete projects open loops. Open loops can be anything: you need to vacuum, you need to walk the dog, you need to call a plumber, you need to pay a bill, you need to go shopping. Anything that causes you to think “ah, I should do…” or “I need to do…” is an open loop.

I’m going to teach you how to handle open loops in Obsidian, and do more important work, every day.

Problems from Open Loops

Have you ever had so much to do that you procrastinated and did nothing? I have, more times than I can count.

Open loops are problematic, because the more of them you have, the more mental energy it takes to do anything. Every time you finish working on something, you have to mentally go back to the list, and sort through dozens of options. Choosing what to do next is often harder than doing the work.

There’s a reason most companies have project managers to tell people what to do. Because figuring out what to do next is hard work!

Getting Things Done posits that you should keep all of your open loops in a task system, and maintain it rigorously in order to stay on top of everything. This works, but that also requires a lot of work, and you need to check in with the system every day. It’s great if you give it enough attention, but for more casual users, it can be a challenge.

Fortunately, Obsidian has some unique tools that give us many more options for managing open loops. Let’s discuss some of them now.

The Key to Handling Open Loops in Obsidian

Here’s the key: an open loop needs to be brought to your attention at the right time. Any system we create for open loops has to take that into account. We want to hide open loops until the right time. How can we do that?

The Folder Approach

One of my favorite ways to handle open loops in Obsidian is with a folder. This is one of the simplest and most effective ways to work in Obsidian.

I use this folder approach for new ideas that go into my vault. If I find an idea that “sparks joy”, I like to add it to my vault.

But adding something to my vault isn’t as simple as just creating a new file. For it to be useful, I always try to connect a new note to at least one other note, thus integrating it into my web of ideas. But creating a “permanent” note that is also connected to related notes isn’t an easy task, and I don’t want to pull myself out of whatever I’m reading in order to do that.

So I try to make adding notes as frictionless as possible, while still ensuring that I go back later and properly integrate those notes into my vault. In Zettelkasten lingo these temporary notes are called “fleeting notes”, so I created a folder named “Fleeting” where all new notes go when they are created.

The fleeting folder gives me a quick and easy way to capture of notes (remember that “collect” is the first step of GTD as well). Then every day or two I go through my fleeting notes folder and “refactor” them into permanent notes.

If you want to try this system, create a folder called Fleeting at the root of your vault. Then in Settings > Files and links set your “Default location for new notes” to “In the folder specified below”. Add the name of your Fleeting folder, and you should be good to go.

Downsides of the Folder Approach

There are a few downsides to this method:

• Doesn’t scale well. The more folders you have, the harder it is to remember to clear your folders out. I would recommend only using this system for one or two of your most important systems.
• Using a folder can hide problems. If you find yourself hiding the folder rather than clearing it out, then maybe you should try eliminating the folder and creating files in the root of your vault, or just leaving that folder open all the time. It’s not a bad idea to play with the structure of your vault to figure out what works best for you.

The File Approach

Files in Obsidian are incredibly flexible, and they make great capture tools.

One of my favorite ways to capture to a file is to use a plugin called Dataview. I like to create Maps of Content that have inboxes that automatically pull in new files that link to them. (If that sounds interesting, see Quickly Organize Notes in Obsidian)

This works great in conjunction with the folder approach above: as I refactor my notes and add links to MOCs, the MOCs automatically update in the background with links to the new files.

But there’s a problem: it is easy to hide things in files. I have many files with open loops that I haven’t looked at in months.

Most of the time I don’t mind, because I only use this system for loops that I intend to ignore for a while. Remember that we want to hide loops until we need them? This is a good way to hide a loop.

Once you’ve written something down and stored it in a trusted system, then you can take your foot off the gas for a bit and trust that if you need that loop again someday, then you’ll be able to find it.

File-based systems aren’t as useful for urgent tasks, but they are essential for peace-of-mind, and in my mind it’s one of the biggest benefits Obsidian has over traditional GTD systems. You can store loops in a trusted system that also allows you to ignore them as needed, which is something I always struggled to do in traditional GTD systems.

After all, if everything is important, then nothing is. Use files to store things that you don’t want to think about now, but want to see again someday.

Note: if you like storing loops in files, and want to ensure that you see that loop again soon, you can use a plugin. The Review plugin allows you to schedule a file for review, and it will bring that file to your attention on the date you specify.

Downsides of the File Approach

• As I mentioned, files make it easy to hide loops. This can be a good thing, as long as you don’t use this system for storing urgent or essential loops. The folder approach is better for things that have to be done, the file approach is better for things that you would like to do.
• The file approach is also a little trickier to set up. It requires some real thought into how you want your file system to operate, and it requires strict adherence to that vision. If you don’t have a system for handling files, then it’s easy to lose them.

The Automated Files Approach

Folders and files can be combined and automated in order to create even more robust systems. My favorite way to do this is by using a community plugin called Dataview, but there’s a lot of automation you can do even without plugins.

For example, you can embed a search query in a note. I touched on automation above when I mentioned my favorite Dataview trick, and this is another way to do a similar thing:

```query
#writing/published
```

This search query will automatically populate any search term you provide. I like to use this when I’m writing: I have four tags I use when writing (#writing/idea, #writing/draft, #writing/edit , #writing/published), and I have a “Writing MOC” which is a note that pulls in notes based on these tags.

This allows me to see the progress of all of my writing at a glance,
and make sure I’m moving articles forward in a timely manner.

Downsides of the Automated Approach

• This approach is more technical and trickier to set up. It also requires some forethought when creating notes, to ensure the correct notes show up in the correct places. This might involve adding specific tags or other metadata to a note to get it to populate.
• If you forget to add the appropriate metadata, notes can get lost. You can create systems for finding lost notes, but that means another system you have to create and maintain.

The Task Approach

Now we’ve gone full circle. We’ve talked about hiding loops, what do you do with tasks that you need to see urgently?

That’s where tasks come in. Task are handy because they have all kinds of tools that allow you to control when you see certain loops.

For example, deadlines. You can add deadlines to tasks, and create queries that will show those tasks on the day of the deadline, or the week, or whenever else you want.

Tasks also have priority levels, so you can add high or low priority, and show or hide them based on that.

Tasks are the end-game when it comes to open loops: if you have a complex working environment and you have trouble managing your time well, tasks might be for you. It’s more trouble to set up than any of the other systems, but it is also the most powerful and flexible system, by far.

If you want to learn more, see How to Manage Tasks in Obsidian.

Summary

Handling open loops is a necessary part of life. We all do it, whether we want to or not. We all have important work to do, and good reasons to do it.

Managing open loops in Obsidian helps me every day to find and execute on my most important projects, and I think it could do the same for you. Give it a try and let me know how it goes!