Some simple rules to follow for myself doing things.


  • Simplify as much as possible. Never repeat myself.
  • Learn from my mistakes. If things fail. Learn from it and move on.
  • Build ideas. Experiment.
  • Share everything I know and made.
  • Be mindful of my actions and thoughts. Don't eat/hurt anyone. Don't waste food/items/time.
  • Don't compare myself to other people. Surround myself with people that inspire me.
  • Be consistent. Make friends with imperfection. Enjoy the process and don't fixate on the goals too much.
  • If an item/thing doesn't provide me any value, get rid of it.
  • Be honest. Don't lie to myself nor anyone else.
  • Adjust these rules and my workflow to match what I have learned.
  • Follow these rules. Take it easy. You only live now.


  • Do deep work. Minimise distractions. Say no to things. Set constraints.
  • Prioritise. Do important things first. Be clear on what I want to achieve. Think long term.
  • Do one thing at a time. Remove friction.
  • Don't visit Tweetbot and other sites that are blocked during the focus session.
  • Think about the problem I want to solve. Don't give up. Don't rush things.
  • If my mind wanders and avoids doing the task, take a walk and do some exercice.
  • Do things that scale. Try to find solutions that scale with time.
  • Reuse other people's work.
  • Use the right tool for the job. Only when you master a tool, do you learn when not to use it. Learn new tools.
  • Start. Don't be afraid to solve the problem no matter how complex or intimidating it may be.
  • Ship early. Get feedback and iterate on it. Rinse and repeat.


  • Always learn new things. Investigate. Why? How?
  • Ask questions. Don't be afraid of not knowing something and ask for help.
  • Ask myself what is it that I am trying to solve or understand.
  • Go deep. Specialise. Be great at some thing and then branch out.
  • Document everything. Don't repeat things. Link instead.
  • Draw. Don't be full digital and use paper and imagination to distill complex ideas.


  • Exercise daily.


  • No processed sugar. No food with extra sugar in it.
  • Drink water, coffee and tea. No added sugar in the drinks.
  • Always have water/tea next to me when working on something. Fill up the water/tea if it empties.
  • No meat or dairy products. Health and ethical reasons.
  • Focus on Whole Food, Plant-Based diet.


  • Sit up right. Don't slouch my back. Take breaks.

Shipping a product

  • Have a nice looking website. The first look matters.

Social media

  • Twitter posts are first made in looking back and are always rallied to Changes section unless the tweet has no preserving value.
    • Images if relevant can be linked and embedded too.
  • Instagram posts are rallied to Photos in looking back. If taken on the phone, it can be done on the mac later or automated.
  • Don't lock myself into using a service. Have my own system in place and give the social media a purpose. If there is no purpose to it, don't use it.


  • Be mindful of the data fingerprint I leave from using a service. If the service disregards my privacy and brings me no value. Don't use it.


  • Giving users too many options is often a bad idea. Give very few options but make each one of them count and stand out.


  • Use proper punctuation and capitalise things appropriately.
  • When adding :, don't add space beforehand.
  • When making tasks (2Do, Trello, GitHub issues), use imperative tense.
  • Remove unnecessary and filler words. Use adverbs sparingly, they often undermine your point.
  • If something can be said in less words, say it in less words. Be clear and to the point.
  • Both in code and prose. Say more with less and never repeat myself.
  • Minimise using word here.
    • When wanting to reference a certain URL, I don't need to mention and you can see it here. I can most likely just change the thing I want to show and wrap that in URL. It looks cleaner this way and saves space.


  • Don't leave unnecessary whitespace between headings and text.
  • Don't need to add : to the end of text when adding image below as it is implicit.
  • Only use HTML to adjust the image if the original size is not what I need. Don't adjust images blindly and check how the final image looks rendered compared to the text.
  • Use Bold for strong emphasis. Use Italic for soft emphasis. And code quotes for actual code, variables, path names and quoting inline (in same sentence).


  • Describe links on the same line with - separator (if needs more description, then sub dash).
  • Interlink entries between each other within wiki where necessary. Don't over do it.
  • Don't repeat myself or anyone else. If something has already been said either by me or someone else, link to it (especially in this wiki).
  • Try to use other services for logging and other things where possible. Like in the case of Letterboxd and its Lists feature. It's better to make lists there and link to the lists from wiki. Find the right tool for the job. The wiki should act as a glue between things.
  • Keep all files lowercased.
  • If I am watching a talk, it is best not to jot down notes from the talk itself but capture ideas and note down these ideas in the wiki, sometimes referencing the talk where the idea or insight was taken from for context.
  • Think about structuring the content and entries as I add new entries. Should a new category be added for the topic (thing) and under what category should the entry be placed.
  • If I move a file anywhere in the wiki, make sure to search for the path to the file in the entire wiki and change the references to the previous file with new one.
  • Don't abbreviate folders and files. Unless it is really clear what abbreviation means.
  • Add links to headings that link to the description of what my wiki article is actually about.


  • Always initialise new projects with Git.
  • Do atomic commits and write proper appropriate commit messages.
  • Start commits uppercased and prefix them with an action (Add/Remove/Fix/Update). Use imperative tense.
    • On larger projects, prefix commits by scope for easier search and index.
  • Don't use emojis in commit messages.
  • Commit changes and push before making a release. This way the commits come bundled together with release as change log.
  • When making changes to other projects, respect their Git workflow and commit style.


  • Add appropriate topics to each repo. Add the languages used in the repo as topics.
  • Make many experiments and share them.
  • Add credits to repos and acknowledge work of people I am using at end of repos. Under # Credits.
  • Use relative links instead of hard wired links. For example in GitHub you can use ../issues/ to reference issues of current repo from readme.


  • Use HTML for rendering images if I need control on their size and position.
  • Add appropriate quote to briefly describe the repo (often is the same as description but with links). Don't repeat what is said in the quote in the description underneath the quote.
  • If the README is long enough, add a Contents reference table.
  • Don't add anything that is not needed and focus on the content.
  • Add a way to visually show the workflow/library in action where appropriate.
  • Don't link to Imgur images as links, render them in the GitHub README itself.
  • In screenshots of Alfred prompts and other prompts, show the cursor.
  • Add Related section to most repos linking to similar projects either of my own or of other. Not all projects need this.
  • Don't add Thank You clause in idea stage projects.
  • Don't add Say Thanks badge on curated lists.
  • When adding resources and bookmarks. Priorotise adding them to LA curated lists first and LA itself (not Trello). The goal of the wiki is to mostly contain my own notes and references.
    • The resources should be moderated and extended by the community through clear guidelines.


  • Comment all my aliases briefly saying what they do. Comment all zsh functions. Be mindful that I can then search through these functions and aliases later.


  • Write code to be read by other people. Prefer to be explicit over implicit. Readability Matters More Than Correctness
  • Make the code run first. Then make it fast (if necessary).
  • Read documentation.
  • Delimit files that have spaces with - instead of _.
  • Use switch cases over long ifs.
  • Function name should describe what it does, not when it's run. Good function names summarize what happens inside.


  • Practice self documentation. Where possible, document things inline in the code base or app itself in some way. Don't duplicate things.


  • Comment over my code. Be mindful of not repeating things. Don't comment obvious things.
  • In comments, don't write Will ... Just write what it will do. Remove unnecessary (filler) words.
  • Uppercase comments for consistency.
  • Use imperative tense. Instead of # Outputs, use # Output.
  • Only add one space after the code for inline comments. Don't space them out.
  • Write a small comment on top of the file to describe the purpose of the file. Where appropriate.

Keyboard Maestro

  • All macro names are lowercased. Unless it is necessary.
  • When doing macros to focus on something, name the macro like sidebar focus rather than focus on sidebar.
  • Minimise inputs and preconditions to macros. Sometimes it's possible that the input I need to a macro, I can get from another place within the macro itself.


  • Try to make semantic mappings and chunk mappings by theme or context.
  • Prefix variable names by action (i.e. EDIT/OPEN/ALFRED). Each variable name should be descriptive.


  • Keyword triggers should be one string (no spaces). Try to make keyword be semantically appropriate to workflow and easy to memorise and type.
  • Name external triggers with spaces between words (lowercased).
  • Release all my workflows (that have no sensitive information) either in small workflows or standalone if they contain quite a bit of code.
  • Name all modifier triggers (uppercased).


  • Use one tree structure for organisation especially when sharing maps (makes the map much easier to follow).

Sharing files

  • Temporary shares with Transfer.
  • More permanent shares are shared with Dropbox. Don't delete items from shares folder unless I delete the file somewhere myself.
  • If the files are stored on GitHub somewhere, I can use Rawgit to get a downloadable link of the raw file.

Sharing my work

  • Share the link to the project on the appropriate website/forum/subreddit.

Releasing workflows with OneUpdater

  • Don't forget to update version number and then also commit the workflow so info.plist on GitHub has the latest version.


  • When preparing for interviews, code up solutions myself instead of looking at solutions. Be able to express solution in my own words.


  • Lowercase and prefix all snippets. Notes can be uppercased.
  • Upload all non personal snippets as Gists.
  • Create smart group for each new prefix I add.
  • Add correct language syntax to every snippet.
  • Prefer to use comments in the code itself rather than notes (easier to follow).
  • Map command line tools in the curated list. Only add commands where I do want to add some optional commands as snippet to SnippetsLab.
  • Attach the URL to snippets as note as a first thing always if URL is needed. Add other notes underneath the URL.


  • Plan the next day fully in advance in the calendar. Follow through with the plan but adapt where necessary.


  • Only contain things I really need to get done in Today.
  • All 2Do tasks need to be actionable.
  • Work on tasks based on priority (starred completed first).
  • Don't include context in the task title since I can do add it as a tag instead.


  • If the idea is not private. Share it in Trello.

Capitalising things

  • Capitalise everything where appropriate (Sentences / Headings / Alfred workflows / GitHub descriptions / GitHub issues and PRs / Comments in SnippetsLab / Main dashed points / Tweets / ..).

Asking questions

  • When posting an error or an issue, give as much relevant information as I can to help debug it.
  • For asking questions about Alfred workflows, link to the workflow you are trying to edit in the comment. And paste the debugger output from when the issue occurs.


  • When asking for feedback, never ask people if they like the product I built. Ask them whether they don't like anything instead.
  • Welcome any feedback. The more critical feedback, the better. Iterate on it.

Ship app

  • Prioritise repos in the sidebar based on priority/urgency.

Thinking map

  • Only have actual things I am struggling to work through there that need slicing (breaking down of smaller tasks).
  • Keep the list to maximum of 5 main nodes in there. If there is more, break them down and move them to either 2Do or GitHub issues and only keep things I am working on.

Reading books

  • Make notes as I read books.
  • Review each book I read on Goodreads and add it to an appropriate category. Add the review to books after.


  • Work to complete the task I have at hand.
  • Set deadlines for all things. Adjust plan according to the deadlines.
  • Deadlines set are of utmost importance. Do my best to complete the deadlines I have set for today before venturing in trying to do anything else. Learn how to deal and set appropriate deadlines with time.
  • Limit distractions. Strive to increase signal to noise ratio.
  • Always turn Focus when starting to work and make things and fully focus on the task/s at hand. Adjust the focus list to block even more distractions and tune my workflow to only do the task/s I have.
  • Live by my calendar. Assign tasks and blocks of time in advance and work through each of the blocks. Adjust when necessary.
  • Always have water next to me.
  • Work away from home ideally.


  • Don't make a card of a fact or something that you can easily look up.


  • Check my work and go through my calculations again. It's easy to miss something.

Product Hunt

  • Add products I like to an appropriate collection.


  • Meet new people.


  • Comment over all mappings in vimrc itself.
  • Only add things that are essential to me and what I actually use.


  • Add all songs I like to my Likes playlist.
    • Add all songs I really like to Favourites playlist.
    • Add songs to other playlists accordingly.


  • Be very aggressive in cutting any kind of distractions when working.
  • Look at where I spend my time in Timing and cut those out with Focus and scripts.
  • Change location. Work from different places.
  • Use one screen when coding. Much easier to context switch.


  • License my own code under MIT.
  • License curated lists and other things under CC0.


  • Prefer to have the prefix reference the meaning in some way for easier mental mapping of prefix to meaning.
  • Name and prefix things with focus on clarity. The semantics of prefixes should ideally be obvious. And naming should be appropriate.


  • Prefer to sleep and wake up at the same time.
    • 5:30AM - Wake up.
    • 10:00PM - Sleep.
  • Sleep for ~ 7 hours each day.


  • Minimise Distracting time and aim at < 1 hour Distracted time a day. Ideally less. Block everything that is Distracting when working.
  • Mark all time past in Timing. Adjust filters and projects to what kind of things I am working on.
  • Only mark non distracting blocks with tasks. Those blocks are ones that matter.

Day One

  • Mark all memorable moments and experiences in Day One.
  • Mark memorable moments throughout the day and put them in Photo a Day and Travel journals.


  • Only use what is necessary. Experiment with things but never keep things you are not actually using. That mostly includes plugins and modifications.
    • Try to establish a good mental model of what you need and what you use as you apprach modifying your workflow and tools.


  • Keep screenshots and interesting images saved in Pixave.

Knowledge indexing

  • Index knowledge that is actionable in case I might need to reference it later.


  • Only run apps I am actually using. Quit everything else.
  • Delete apps I am not using and have no need over. Only use what I need or may need.
  • Have full control over what is going on my system to a reasonable degree. Don't use/install things I do not actually need.


  • Do emails in burst. Bring my inbox to 0 every day. Action on each email.
  • Archive emails if I want them to be searchable later. Delete emails otherwise.
  • Star emails that are important and I may need to reference late.
  • Sort newsletters automatically into groups for later viewings.
  • Only show relevant emails to me in Inbox.
  • Label all emails accordingly (if it is appropriate).

Looking back

  • Don't say Want to. Instead say Will in Changes. This applies more generally too, try be more proactive with anything I do. Intention counts.


  • Track every purchase made with YNAB. Put every purchase in its respective category.
  • Adhere to my budget that I have set for each of the categories. If there is no budget left for eating out. Don't eat out.
  • Keep receipts of expensive purchases for warranty.



  • Watch talks and tutorials at 1.25+ speed. Unless it hurts comprehension than watch it at slower speeds.


  • Don't save unnecessary information. This mostly concerns tracking data and the like. More data is not always better. Quality and purposeful data is.
  • Make the data actionable in some way. Either as a way that you can query it later and read or look back upon in the future (as is case with Day One) or as a way you can immediately take action on in form of analysis of it.
    • Knowing what goals you have and the reasons why you are collecting or using certain kind of data is important and saves a lot of time in the future when you want to minimise and simplify things in life.


  • Data that is not backed up is lost data. Automate backups.


  • No need to create Doing now and Do next blocks. I can use watching feature for that and seperate cards instead by topic. Use tags to give priority to tasks. (In my case Important and Next are always present tags in most boards).
  • Share boards publically that contain no sensitive or private information.
  • For boards like Learn and Books, no need to add links to cards as the links to these things should already be added in LA curated lists which are easily queriable.


  • Check everything once I leave a room. In case I forget anything.
  • Avoid confusion. Don't use anything only I can understand.
  • Be aware of my own quirks and ask myself why I do what I do.
  • Don't overthink things to the point of not doing anything.


  • Everything evolves with time. Projects, articles, ideas will evolve with time and will never be what I first envisioned them to be.

results matching ""

    No results matching ""