How to work efficiently, how to efficiently get things done, and how to make the team operate efficiently.

Org-Mode + Git + 20-minute rule

People always ask me how I manage to complete a project and successfully deploy it to production or clinical applications in such a short time. Many times, people doubt the feasibility of the timeline I provide. However, I often end up successfully delivering one milestone after another according to my own timeline.

The saying "Give a man a fish, and you feed him for a day. Teach a man to fish, and you feed him for a lifetime" applies here. So, I am planning to write a long post to discuss and explain in detail my own philosophy and specific implementation methods in my work, which have been tested in practice.

Let's start with the tools I have used before. For knowledge management and documentation, I have used various tools such as wikis, logseq, Evernote, Confluence, and Obsidian. For team collaboration and task assignment, I have used Jira, Teams, and others.

However, from my personal experience, whenever there is any friction between the users and the tools they use, the overall efficiency decreases significantly, and the desired results cannot be achieved.

After years of practice, I have realized that the most efficient file format is actually ASCII text files. They are supported by various editors and each person can use their preferred editor, whether it's VIM, Emacs, Notepad++, Sublime, Atom, VScode, or any other tool they are comfortable with. To ensure high-speed collaboration within a team, it is important to allow each member to use their preferred tools.

The most powerful ASCII file format can be considered as org-mode in Emacs (https://orgmode.org). You can find detailed information on the official org-mode website.

I have been using org-mode in Emacs to manage my personal learning and life for more than a decade, and it has been very effective.

The core of getting things done (GTD) lies in two points: Capture and Action.

The key to capture is to quickly record ideas, plans, or tasks anywhere and anytime. In practice, this requires configuring global shortcuts or keybindings to achieve this effect. The goal is to quickly and comprehensively collect information, assign tasks, and set actionable items to ensure high efficiency in the project team.

The key to action is how to quickly start a task and prevent procrastination. In my previous teams, we used Jira for a long time. Although Jira is a good agile tool, there was still some friction in its usage. When a user adds or modifies a ticket, they need to open a browser, find the corresponding project, and go through several mouse clicks before they can start entering the details. This is the problem I mentioned earlier. For users, there is friction in the usage, which leads to an adoption hurdle and overhead.

On the other hand, when using an editor to open an org file, as long as the editor is not closed, all my task lists, specific records, and plans are readily available. I can quickly view the details, complete my to-do list, and move on to the next task.

For a system to run smoothly, the tools are the first consideration. From an organizational standpoint, the core of my system is: ASCII files (org-mode) - Git Repo (can be GitHub) - scripts running in the background (using bash on Mac/Linux or bat on Windows).

I used to primarily use Emacs, but in recent years, I have switched to Sublime Text. Let me share some configuration experiences with Sublime Text. There is a plugin for org-mode called OrgExtended (https://github.com/ihdavids/orgextended), which provides partial support for org-mode. It is sufficient for my personal and company projects.

Facebook's Zuck often says that his rule is to break down tasks that exceed 25 minutes. My personal guideline is to break down any item that exceeds 20 minutes into subtasks. This ensures that I can start working on the task quickly and avoid procrastination.

Here's a simple example of an item and subtasks for a project that one of my employees is working on. My rule of thumb is to record all tasks and break them down into blocks of less than 15 minutes.

The top-level item above represents a simple feature I requested him to complete, and all corresponding tasks were immediately decomposed. If a task exceeds 15 minutes, it is further broken down. This ensures that he can immediately start working on actionable items.

Why do I emphasize this? Because if your task takes more than two hours to complete and you don't break it down, chances are you won't start working on it immediately. Starting is often the most challenging part of completing a task. Once you can start working on it, you will enter a state of flow, which will help ensure that the work is completed.

Why do we need to record everything? On one hand, it improves the coherence of work for both employees and myself, boosting efficiency. This way, at any given time, everyone knows what needs to be done and what tasks require immediate attention. On the other hand, since we are in the medical field, all these tasks ultimately require FDA approval. When applying for FDA clearance, all these tasks need to be traceable and documented. This way of working naturally ensures compliance.

Previously, we used Jira and Confluence, Atlassian's tools, for project and document management in our company. Now we have completely switched to Org mode. Firstly, Org mode is based on text files, so creating a new document simply means creating a new Org file. Secondly, I prefer having documents and TODO lists together. The benefit is that actionable items and the corresponding information are all in one place, eliminating the friction of searching for information separately. The screenshot example I provided earlier in the conversation follows this approach.

Then let's move on to some details. Devils are in the details.

For team collaboration, an important aspect is to use a Git repository to automatically synchronize everyone's work progress and allow everyone to see it in near real-time.

Firstly, I wrote a script that runs in the background and automatically pulls/merges/pushes an Org directory to our company's corresponding repository every 30 seconds.

Sublime Text supports automatic document reloading. When a document is updated in the background, Sublime can automatically reload it without any user intervention. To ensure this setting is enabled, you can open the settings and make sure the following setting is set to true:

    // Whether to reload a file if it has changed on disk.

    "reload_file_on_change": true,

As shown in the screenshot I provided earlier, each employee can see other people's commits, along with the completed work or newly created tasks. This mechanism ensures self-motivation and self-discipline among the team members. I often say that when hiring a new employee, I don't primarily focus on whether they are smarter than others, but rather on whether they have self-motivation and self-discipline.

Another advantage of Org mode is that GitHub's online interface directly supports this format. When opening the corresponding file in a browser, you can see a formatted interface, making it convenient for explanations or sharing during meetings.

Sublime Text's keybinding feature is convenient for integrating various useful shortcuts into my workflow. For example, I often use the following format to add notes to tasks in Org files:

#+BEGIN_EXAMPLE

    My Notes

#+END_EXAMPLE

Org mode automatically formats these notes. I added the following line to my Sublime keybinding settings:

{ "keys": ["ctrl+c", "ctrl+i"], "command": "insert_snippet", "args": { "contents": "#+BEGIN_EXAMPLE \n${0:${TM_SELECTED_TEXT}}\n#+END_EXAMPLE"}}

So when I press Ctrl+c Ctrl+I, the above format automatically appears, which is suitable for inputting notes.

In the Getting Things Done (GTD) philosophy, one important aspect is to assign specific statuses and priorities to all tasks, categorizing them based on their status and importance. As shown in the screenshot I provided earlier, I do this by giving each task, project, or item different statuses such as TODO/IN-PROGRESS/Waiting/DONE. At a glance, I can see the current status of each project.

Regarding priorities, I add tags in the format of [#A]/[#B]/[#C] to each project. Org mode displays these tags in different colors, allowing me to quickly determine the priorities of projects.

For other project-specific attributes, such as assigning a task to a specific person, I use tags like :name: to quickly assign tasks, and employees can easily see these tags in their synchronized files.

Only when tasks are assigned specifically can your efficiency flow. You will realize this once you actually try to do it. The time spent on task planning is completely worthwhile.

When I emphasize the need for self-motivation and self-discipline in employees, in practice, I only provide them with a specific major task and direction. The specific sub-tasks are to be done and completed by them. However, they must follow my guidelines: 1) tasks that take less than 20 minutes must be broken down, and 2) every task definition must be an actionable item.

Some people may wonder if the file will become larger and slower with this approach. The answer is no.

Org mode supports archiving, so I can quickly move a project that has changed to the "Done" status to the archive. This ensures that the current file remains efficient.

The principle in my current company is to recommend creating a separate Org file for each project. Generally, I create a new Org file corresponding to each month and conduct a review at the end of the month. Only the necessary projects are copied to this new Org file, while the rest are archived.

This list will definitely continue to grow. Initially, it doesn't need to be divided into too much detail. The key is to be able to start quickly and add new projects efficiently, which are the two important points I mentioned earlier.

Capture and Action

Another advantage of Org mode is the ability to quickly open and close folding for corresponding projects using shortcuts. For example, on a TODO line, I can click Tab to quickly open and close the folding for that project. I can use Shift + Tab to cycle between the folding of all projects quickly. I can also create keybindings for different situations. For example, I define this keybinding:

{ "keys": ["ctrl+c", "ctrl+z"], "command": "org_fold_all_but_me", "context": [{ "key": "eol_selector", "operand": "text.orgmode"}] },

It allows me to close the folding of all projects except the current one using Ctrl+C, Ctrl+Z.

Another keybinding I frequently use is for quickly toggling the status of a task. For example, for a checkbox task, I can quickly switch it to the "completed" status, or for a TODO item, I can quickly switch to other statuses:

{ "keys": ["ctrl+c", "ctrl+c"], "command": "org_toggle", "context": [{ "key": "eol_selector", "operand":"text.orgmode"}]},

This allows me to toggle the status by clicking Ctrl+C twice.

In the screenshot I provided earlier, another convenient feature of Org mode is using "[%]" to track progress. I can place this symbol at the end of any parent project line, and Org mode will automatically calculate the progress of that project.

The analogy I often use when talking to my employees is this:

Imagine if you're a regular runner, let's say you run a 5K. If you focus on a distant point while running, you'll feel increasingly tired because the goal seems far away. But if you focus only on your footsteps, taking one step at a time along the route, you'll find that the 5K is completed quickly. This is because you can concentrate on each step without worrying about the distant long-term goal.

The same analogy can be applied to project planning. Focusing on each detail and subtask allows you and your employees to concentrate on the immediate work and progress the project gradually.

----------------------------------------------

When it comes to implementation, there are always a bunch of details to consider.

For example, in Sublime Text, there is an issue with Folding not being preserved when restarting or reloading files.

I often make modifications to my org files in other places, or other employees make changes, and when I do a git pull, Sublime automatically reloads the file. But then my previous Folding is lost, which is quite annoying.

I tried almost all the plugins in Sublime that claim to support preserving Folding, such as AutoFold, AutoFoldCode, BetterScroll, and so on, but none of them could provide the functionality I needed.

The reason behind this is that the Fold state corresponds to two lines for each folding. If there are new lines in the file after it has been updated in the background, the editor doesn't have specific information about them. Unless the file is completely re-parsed by recording only the line numbers, the Fold state cannot be preserved. Unfortunately, Sublime itself doesn't support this feature.

So, I had no choice because I had already switched from Emacs to Sublime, and many muscle memory shortcuts had been established. Therefore, I spent over an hour reading the Sublime API documentation and started from scratch to write a new Sublime Text plugin that supports the folding functionality I need in Org mode.

Finally, I feel comfortable now.

I hope you find this information helpful. Let me know if you have any further questions or if there's anything else I can assist you with!

[This is a post translated to English from coolwulf’s V2EX post at: https://v2ex.com/t/887733]