The problem with first-principles thinking is that you don’t know what you don’t know. You might end up deriving the same thing you could have read in a 101-level textbook. You might think you have a novel idea of a blockchain-powered utopia but it turns out it’s Georgism with extra steps.

On the other hand, first-principles thinking solves the problem that you don’t know what other people don’t know. People make mistakes in their thinking that may directly or indirectly influence your thinking. Godel’s incompleteness theory tells us that there are always things we don’t know.

Now we have a conundrum—you don’t know what you don’t know and you don’t know what everyone else doesn’t know.

So when should you apply first-principles thinking?

Low epistemic status ahead!

As the default on the edge and as a counterbalance in the middle.

Imagine knowledge about a given area of inquiry is a two dimensional field (e.g. distributed computing, socialism, space travel, etc.). Beyond the edge is the unknown. The further you move from the center the longer the path of propositions that must hold true for that point to also be true.

At the edge, first-principles thinking is essential. New technology, techniques, and ideas can make finding new knowledge possible. Uncovering flaws in the long line of propositions that got the field to the edge of what’s known can also be fruitful. Perhaps there was something wrong that is easier to see from the edge looking back.

In the middle, being dogmatic about first-principles thinking is a reductionists trap but a useful counterbalance. If you never think from first-principles (even in the well-trodden middle) you’ve essentially outsourced your thinking.

See also:

• The Incomplete Guide to the Art of Discovery
• Richard Hamming talks about this in terms of academic success in You and Your Research

When building a B2B service that has a public signup page, it can be useful to exclude signups from a free personal email provider. They can be used by malicious individuals to get through simple forms of email verification. Introducing a small amount of friction doesn’t hurt your actual customers but does make it more annoying for would be attackers.

I found this list from ammarshah is a good starting point for a block list.

The first sentence of every paragraph should be a BLUF. Readers can see the point right away without having to read through the entire paragraph. Readers don’t need to piece together the meaning themselves.

Most people write in the inverse—they put the summary of the paragraph in the last sentence or muddled somewhere in the middle (or not at all!).

How do you do it?

Paragraphs should read like a miniature recipe or categorized list. Take the most important idea in the paragraph and put it first. Follow with supporting sentences that are inductive (rather than deductive).

You can see this style in practice by deconstructing this page. If you take the first sentence of each paragraph it should still be understandable—albeit in lower fidelity. If you take each paragraph and turned it into a bulleted list, the category of supporting sentences should all have the same subject.

See also:

• The Minto Pyramid Principle covers this and how to structure writing so it makes sense overall
• This is another way of saying always give the summarizing idea first whether it’s a paragraph or the structure of an essay

This note does not have a description yet.

Founders get away with a lot in founder-led sales. They know the product and the problem inside out. They have the most context from talking to users (hopefully) and can pivot the conversation when they identify a challenge. They have conviction about what the business which makes you want to believe them.

This doesn’t necessarily translate to a playbook others can use to sell. The real test is going from founder-led sales to a repeatable sales process.

How do you do that?

I’m still figuring this out for myself but here’s some advice I’ve gathered from talking to other founders and early sales hires.

Hire a generalist to take over doing sales calls along with the founder. Their job is to document the process and work with the founder on developing the playbook—they don’t need to be a salesperson.

Alternatively, develop a playbook first and hire two Account Executives. You need to hire two so that you can evaluate performance better. Test out the playbook and work with the two AEs to make it better.

The playbook itself should be much more detailed than you think. There should be clear stages in the customer journey documented to help the salesperson provide structure to the customer. It’s only a process if it can actually be written down and used to train others.

In the early days of a startup with a product in the market, it seems intuitively correct that you should hire some experienced salespeople to get you more sales. However, from many conversations with founders and early sales hires of B2B SaaS companies, I’ve learned it’s best to start with customer success first.

Retention is key. Early customers are the ones talking about your product to their peers. They’re the ones helping you figure out the product by providing valuable feedback. They’re the ones expanding revenue for you without having to acquire new customers. If you have a low retention rate, you won’t get the benefit of any of these things.

Then there’s the leaky bucket problem—when you’re trying to grow but need to replace a significant amount of revenue lost to churn, everything is much harder. You’ll need to hire more salespeople to acquire more customers. You’ll need to do more marketing. You will need to address customer success even if you ignore it at first.

Customer success also helps in the same way founder-led sales helps identify product problems. Helping users implement and see the value of your product can reveal opportunities to make it easier and make it clear how users are trying to solve their biggest challenges.

See also:

• Founder-led sales

I don’t use tags as a way of querying topics. Instead, I use a use a small set of tags (FILETAGS in org-mode) to drive functionality for task management and notes.

A project tag is used to connect tasks with org-agenda. That way my notes are not separate from day-to-day work.

A private tag or draft tag is used determine whether or not to publish the note publicly. I sometimes search for drafts to finish them up later though I don’t always come back.

An entity tag indicates a person or company. This is similar to an at mention to associate a task with a person. Using org-roam back, I can query tasks by person so I can follow-up on delegated tasks or review work later.

A Twitter thread of findings from studies about Long COVID and its association with neurological symptoms.

Part 1: https://twitter.com/AndrewEwing11/status/1487473810915876864

Part 2: https://twitter.com/andrewewing11/status/1586500342841475072

See also:

• 14% of US adults have had Long COVID which can have a large impact on society

I read about Steven Wolfram’s personal infrastructure. He develops his approach to just about everything using the tools that he built. I’m guessing this approach works great for building Wolfram as a giant feedback loop but not directly transferable to others.

Some of the ideas I liked were combining emails and notebooks as primary sources for working on various projects. The starting point and rallying point for all his work are notebooks though.

Over the years, I’ve accumulated over a hundred thousand notebooks, representing product designs, plans, research, writings, and, basically, everything I do. All these notebooks are ultimately stored in my filesystem (yes, I sync with the cloud, use cloud files, and file servers, etc.) And I take pains to keep my filesystem organized—with the result I can typically find any notebook I’m looking for just by navigating my filesystem, faster than I could formulate a search for it.

He files them all manually using a simple strategy of active vs archive laid out as projects. The filenames themselves are ordered but that’s about the extent of the filing schema.

That seems like a more useful way of organizing things (what am I trying to do? or what am I trying to answer?) rather than generic buckets of “work”, “personal”, and “refile” like I use. Maybe it’s time to start bucketing things more intentionally (though for org-roam, I’ll stick with structure notes for that) and stop worrying about cross listing.

He also talks about writing in notebooks, mixing them with screen captures and sometimes running computations in them. This reminds me of org-mode and using org-babel to evaluate code and display the results in the document (or even in-line using org-macros).

There is an extensive indexing system he uses for personal search. This includes emails and notebooks, which again, seems very useful than the disjointed experience most of us have because our digital lives are siloed. He seems to have solved that for himself and building a company to do it (half joking).

Then there is a personal dashboard that serves as a jumping off point between all of his resources that he revisits many times per day. I find that using org-agenda for work is starting to serve a similar role (for example, listing goals as well as tasks).

I want to combine org-roam setup with my task management setup for work.

This will:

• Add the concept of a ‘project’
  • org-capture can be used to create projects, capture tasks, and refile them to the correct project
• Make agenda view more flexible to organize around what I’m trying to do instead of partitioning by work or personal
• Add the ability to organize using backlinks (e.g. find associated people, related projects)
  • Mention an entity by inserting a link and typing
• Resolve the split-brain problem between work and private life

Biggest risks:

• Notes are publishable and public by default, accidentally leaking information would be bad
• Latency of org-agenda could make it unusable if all org-roam notes can become projects

See also:

• Steven Wolfram - Seeking the Productive Life - literary notes
• The Great CEO Within talks about the basics of what a GTD system must do

DONE Implementing org-roam for work

[2022-11-05 Sat 08:45]

• Create a project template for org-roam-capture Add project tag and private tag to the tag vocabulary
• Create a person template for org-roam-capture This will be used to link a person to notes and projects. It will also be used to generate tags automatically to make finding tasks grouped by person easier
• Create a project note template Add a private tag to make sure it’s never published add a project tag so we can search later for only projects
• Migrate one project to the new format
• Project names look ugly when using org-roam slugs Is there a way to use the title instead of the filename in org-agenda?
  • Can set the CATEGORY property to the title of the project
  • Modify org-agenda-prefix-format but you can’t template the title property and I couldn’t find an expression that would work inline

    (org-agenda-prefix-format " %i %?-12(org-format-outline-path (list (nth 1 (org-get-outline-path)))) ")
    

• How will this work on mobile?
  • Use Beorg? Hooking up my zettelkasten files will slow it down/crash it
    • Is there a way to limit which files Beorg picks up?
      • There is todo-exclude-files but there is not a way of specifying add just these files
    • Maybe just use it for capture on the go but not an agenda
    • There is a “subfolder” feature that adds a notes tab but it won’t pull in tasks automatically
  • Use Working Copy and sync with git pull/push
    • Would need to remember to commit and push when stepping away from the computer
  • Decided on only using Beorg for capture on the go, that’s it and that’s all it can really do in this system without significant effort to sync a dynamic list of files to Dropbox
• [-] Should all work tasks be tagged? Will that make it easier to partition? Will come back to this
• [-] Update the find note commands to exclude work or personal notes Will come back to this when it’s needed

DONE Update org-agenda to always include org-roam files tagged as projects

[2022-11-19 Sat 07:53] For now, add each project to the agenda list files C-c C-[

DONE Search for only projects not all notes

• State “DONE” from “TODO” [2022-11-19 Sat 08:06]

[2022-11-19 Sat 07:43]

(defun my/org-roam-node-find-project ()
  (interactive)
  (org-roam-node-find
   nil nil
   (lambda (node)
     (seq-contains-p (org-roam-node-tags node) "project"))))
(global-set-key (kbd "C-c n p") 'my/org-roam-node-find-project)

Self-serve businesses that sell complicated software (like an API) can use documentation as a way of augmenting or replacing customer success. For example, early Stripe did not have sales or support but created outstanding technical documentation that was always available—you didn’t need to schedule a call to discuss implementation or answer questions, you could figure it out yourself.

Having really good documentation enables a different kind of go-to-market plan. It wouldn’t make sense for a business to build a Customer Success organization to spend a lot of time with customers spending very little. Documentation enables selling to segments of the market at scale that would previously be cost prohibitive.

See also:

• Documentation is also a form of automation and in this case it seems to automate customer success

It’s surprising how much selling happens by sending follow-up emails. We all lead busy lives (for better or worse) and a well-timed nudge can result in a sale. I would estimate that this single behavior generates billions of dollars of revenue per year.

See also:

• A third of sales comes from doing nothing at all but some persistence is still required.
• One of the problems with founder-led sales is that founders juggling many things might drop this simple behavior and miss out on some sales

An easy way to spot bad business writing is to check if it poses and answers a key question. Even a highly detailed document that goes to great lengths to explore a subject is not useful if it leaves it up to the reader to figure out what to do about it.

I can imagine there is hesitation in putting oneself out there by answering the question. There’s the possibility of being wrong and that can feel risky. However, a huge part of effective business writing is answering the question which was important to write about in the first place.

See also:

• The Minto Pyramid Principle
• This is an example of the principal-agent problem, the principal wants to solve problems, the agent wants to avoid being wrong
• Problems are conflicts between ideas, if there is no conflict then there is no point in writing about it

An experiment suggests that quantum processes (entanglement) might be used by brain functions which could explain memory performance and conscious awareness.

The researchers used a quantum gravity experiment to measure the proton spins in ‘brain water’ using an MRI. They deduced that the likely explanation for entanglement they observed is that the brain must have quantum process mediating it.

If the brain has quantum processes the implications for AI research and quantum computing could be huge. The two fields might be more closely linked than we thought.

See also:

• This sort reminds me of the book Hard-Boiled Wonderland and the End of the World—if the multiverse theory is correct, might we experience infinity in our thoughts?

Tupper’s formula displays its formula when plotted on a graph. This is a form of recursion but more like a mirror. Compared to Godel’s incompleteness theorem (also self-referential), Tupper’s formula is more like perception not reception—it does not create new meaning in a system unintended to do so (Principia Mathematica) and is more like a reflection of itself.

See also:

• I Am a Strange Loop goes into great detail about recursive systems and developing meaning from systems incapable of expressing meaning
• Straussian reading is another kind of recursion where the meaning emerges from multiple layers of understanding about the context of a piece of text rather than the literal transformation of a linked list of ideas into a tree

One of the key points of I Am a Strange Loop is how the “I” develops into consciousness. The constant reinforcement (and self-enforcing) of the “I” gives rise to perception, symbols, meaning, and reality. On the other hand, the key point of mindfulness (at least to me) is recognizing the illusory self.

If the self is an illusion then it must not be real. The “I” is merely an abstraction over consciousness that disappears upon closer inspection (in meditation, this is the “look for the one who is looking” idiom). However, abstractions themselves are real.

Does the “I” give rise to consciousness to begin with or is it the other way around? Does the failure to inspect the strange loop in consciousness make it an illusion?

Maybe both are true. Everything arises in consciousness and the “I” is inseparable from reality.

In org-mode, macros can be used to expand text but are only visible when exported. However, by combining org-macro and emacs' built in font-locking system, you can expand macros inline in the buffer.

For example, here’s a macro that expands to the text returned by an elisp expression which gets today’s date. In the buffer, you don’t get to see the expanded value (though it does show up if you export it).

#+MACRO: today (eval (format-time-string "%m-%d-%Y"))

* Today's date is {{{today}}}

Adding the following to your init.el tells emacs to font-lock text in org-mode buffers when it sees triple curly braces. Using the display overrides the text shown when there is a match. Then the macro is expanded programatically the same way (for the most part) org-mode does it during export.

;; Display macros inline in buffers
(add-to-list 'font-lock-extra-managed-props 'display)

(font-lock-add-keywords
 'org-mode
 '(("\\({{{[a-zA-Z#%)(_-+0-9]+}}}\\)" 0
    `(face nil display
           ,(format "%s"
                    (let* ((input-str (match-string 0))
                          (el (with-temp-buffer
                                (insert input-str)
                                (goto-char (point-min))
                                (org-element-context)))
                          (text (org-macro-expand el org-macro-templates)))
                      (if text
                          text
                        input-str)))))))

Now you can see the macro expansion inline in the buffer.

#+MACRO: today (eval (format-time-string "%m-%d-%Y"))

* Today's date is 2022-10-29

This quote by Jeffrey Pfeffer, professor at Stanford GSB, sums up the difficulty of achieving something different by doing the same things. You can apply this to “success” or any venture really. For example, it’s highly unlikely that Tony Hawk became the best skateboarder ever by living a conventional life.

There is an important nuance that I think people forget—it’s not about personality, it’s about behavior. Emulating Steve Jobs personality completely misses the point, his moodiness and assholery did not a good product make. It was the cultivation of taste and building a cathedral with maniacal focus and decision making. He was extreme, but I highly doubt being an asshole was the essential part.

See also:

• “Extreme people get extreme results” from Sam Altman’s essay How To Be Successful.
• Controlled self-deception

This is a work-in-progress as I’m still refining an org-agenda centric workflow. Here’s what I’ve learned so far.

The key problem I think this system should solve is 1) trust that something wasn’t lost or forgotten 2) what to do next. Everything else is nice to have.

You can’t get everything into org-mode. There will always be some incompatibility like getting your calendar synced using GCal. If you don’t accept that, you’ll never actually use it.

The default org-agenda has too much stuff going on if you have 100s of items. I realized I need multiple views of the same things to keep focus. One for the day and another for a fortnight. I look at the day view the most because it has mercifully few items. I look at the fortnight view to think ahead and plan.

Having separate org files is a bit cumbersome. It’s best to always use org-agenda to interface with tasks. Otherwise, there is a lot of manual file opening and searching.

Including goals at the top of the agenda to help focus my attention on what matters. I wrote a small function to inline macros in the buffer so I can see things like how many days are left to hit the goal.

Business problems that are being solved with software tend to reduce to a data modeling problem.

The share of remote job postings across the US, UK, NZ, CA, and AUS have increased since the start of the COVID-19 pandemic. The following chart was reweighted based on occupation distribution in 2019.

Source: Remote Work across Jobs, Companies, and Countries

Job postings are a lagging indicator of the number of jobs that are being done remotely along with office real estate decline and office occupancy rates.

I watched a press conference of Bill Belichick being asked about long snappers and whether it’s worth having a dedicated roster spot for a specialist. I don’t particularly care about this but I was struck by how thorough and detailed Bill’s answer was.

He explains how the league started with more generalists—players who could do special teams and long snap. As strategies changed, it became more important to have a specialist long snapper who could block. If you saved a roster spot by having a player who performs more than one role well, there is a risk they could be injured. The league evolved to specialized roles for punters, kickers, and long snappers as a result.

I watched all 10+ minutes of it because it reminds me there is infinite detail in just about everything. Things can seem so simple and but is more likely a failure of imagination of how deep it goes.

There should only be one primary action the user can take on the screen at a time. When there is more than one action to take it becomes confusing. Which should I do first (ordering)? Which am I supposed to do (decisions)?

As a simple analogy, think of the difference between a plane’s cockpit and a soap dispenser. The former is filled with knobs and switches for all sorts of functions, the latter has only one thing you can do—get soap.

If you want to make UI feel intuitive, requiring little to no explanation, distilling the interface into a series of single actions (choices) is your best bet.

That doesn’t mean there isn’t a place for more complicated interfaces, but if you see this happening, you’ll know it increases the level of understanding needed by new users.

Coordination in the absence of communication. For example, two players in a game can’t talk to each other but they want to team up for a quest. They show up at a time that seems most likely (noon) on a day that is most likely (New Years) in a place that’s most likely (an inn). This works because people can use the shared context of their world to superimpose coordination.