Writing is like taking an idea and turning it into a rigid object. When ideas are fluid they become flexible and imprecise, able to fill into whatever context is needed—those “that’s not what I meant” moments and contradictions others allow us to have in conversations.

Writing demands the opposite. As you add sentences to the page, ideas takes shape and solidify, and so do the cracks. It becomes more obvious what you don’t know and your arguments fall apart under closer inspection. Cracking can lead to outright breaking of the idea, leading you to disagree with the original premise altogether.

From Writing to Think by Henrik Karlsson.

See also

• The easiest person to fool is yourself
• The illusion of explanatory depth is another way of seeing how flimsy your understanding is
• Thinking better thoughts

According to the Bureau of Economic Analysis, the contribution to US GDP in Q1 2024 of professional services industries was more than double that of information industries (which includes softare publishing).

That means, technological advancements in artificial intelligence could be a larger disruption than the entire SaaS industry. At least Bessemer seems to think so in their State of Cloud 2024.

From the report BEA report:

In 2024Q1, Professional and business services nominal value added was 12.9 percent of GDP and increased to $3,654.1 billion.

Professional and business services (PROF) is an aggregate of professional, scientific, and technical services (54); management of companies and enterprises (55); and administrative and waste management services (56).

In 2024Q1, Information nominal value added was 5.4 percent of GDP and increased to $1,523.9 billion.

Information (51) includes publishing industries, except internet (includes software) (511); motion picture and sound recording industries (512); broadcasting and telecommunications (513); and data processing, internet publishing, and other information services (514). Establishments produce and distribute information and cultural products, as well as data or communications, and process data.

Using org-mode and org-roam can make a rudimentary CRM system for logging interactions with people, companies, or any other contact.

Capturing associations

1. Create a file for each entity (use org-roam and a capture template to automate it)
2. Insert a link to the entity (org-roam-node-insert) in tasks, meetings, or any other notes to make the association with that entity
3. Visit the entity file and view backlinks (org-roam-buffer-toggle) to see all related items

Adding more CRM functionality to org-mode

Now that there is a rudimentary CRM, we can use org-roam’s database to build more functionality.

• Check-in with contacts: Use the list of backlinks sorted by date to see who you haven’t talked to in awhile.
• Get a list of tasks waiting on a contact: Use backlinks that have a status of WAITING to bring up at the next meeting.
• Adapt at mentions for org-mode to quickly tag contacts to make associations
• Create a capture template for each kind of contact (company, person, etc.) to store standardized properties like company name and website

See also:

• Personal CRM
• Start a personal CRM as early as possible, though LinkedIn is a pretty good place to start

Software abstractions save us time doing work by not having to write programs from lower level building blocks. Programming languages like Python provide an easier way to write general purpose software than say, assembly language.

However, abstractions don’t absolve us from having to learn about lower level building blocks because they always seem to leak through to higher levels. For example, you can’t build a web app using React without debugging an issue with hooks that have to do with async JavaScript once in awhile. Eventually, we all need to learn what lies beneath!

From The Law of Leaky Abstractions.

See also:

• Abstractions are real
• Choosing boring technology can help find higher quality abstractions but the same laws apply, just less frequently
• Good magic and bad magic
• TypeScript undermines the value of the JavaScript ecosystem and static typing

A problem that crops up often in web design is centering. No not how to center a div, but how to visually center an element vertically. This is different than merely centering vertically using flex or grid because when you have elements like a top nav that takes up space, the vertically centered element will appear too low on the screen even though it is technically correct (50% of the parent element).

Is there a reliable way to solve this problem without having to remember to offset everything by some amount?

Working asynchronously is an important reason why remote teams work. However, it can devolve into anti-patterns.

For example, writing a brief and then sharing it for review but not waiting for all feedback will over-emphasize comments by the first to review (an organizational availability bias?). Sometimes the mere presence of other comments in a document is enough to disuade someone from adding their feedback, incorrectly assuming someone else already covered what they would have said.

What can remote teams do about this?

There are a few practices async teams can adopt to avoid these pitfalls.

First-to-review bias can be mitigated by seeking targeted feedback at the same time as sharing it broadly.

For example, in Slack say:

“Here is the brief on {THING AND LINK} for review.

{LIST OF PEOPLE} can you please provide feedback on {LIST OF AREAS ACCEPTABLE FOR FEEDBACK} by {WHEN YOU NEED IT}?”

Organizationally, help people understand that async means more work gets done in parallel but more slowly. It can take time to wait for the right collaborators and to get the right feedback. Asnyc should not be used as a shortcut to speed things up (like accepting the first feedback and moving on as in the earlier example).

(This idea was borrowed from something I heard Alex Norcliffe said.)

See also:

• Another example of how remote teams need to be more deliberate about everything
• The best way to speed up gathering feedback is to make sure briefs always answer a key question
• Automating cooperation decreases the cost of coordination

Using a UI is a form of deductive reasoning that takes effort. You need to build out a plan on how to get what you intend. You need to follow interaction patterns you’ve seen before. You need to have built an intuition for where to look and where to go. You need motor skills to engage in just the right way to induce the transition of the state machine.

Generative AI tools can decrease effortful UI by inverting this pattern—start with what you intend and offload the work of figuring out how to get there.

As an industry, I think we are only just starting to build the intuition of where to tastefully apply AI. One heuristic is to look for oportunities in your product that require a lot of UI or tacit knowledge and imagine how this effort could be replaced with AI.

(From conversations with Michael Pons)

Low bitrate audio codecs are primarily used for downscaling audio for slower internet connection speeds and supporting older devices. They can handle high rates of packet loss while still sounding natural. For example, Opus 1.5 still sounds good at 6 kb/s and narrowband sampling rate (8 kHz compared to 48 kHz).

I recently shared some observations about trying to use generative AI tools at work and shared the experience on LinkedIn.

As an experiment, the Mosey team paid for a bunch of generative AI tools (Slack AI, Notion AI, OpenAI, GitHub Copilot) and tried to incorporate them into our everyday work.

Here’s what we found.

Summaries, while boring, are extremely useful. Slack recaps help everyone maintain “ambient awareness” of other projects without getting overwhelmed. It helps that our communication norms default to in-public and in-channel (not DMs).

The barriers to trying new things with AI are so low you can just “play with it” really quickly. Small prototypes that previously felt like a lot of work can be spun up in hours—a signup spam detector, generating configuration data, analyzing a report, a classifier for mail—all started with a one-off prompt to see what happens.

AI tools excel at making sense of unstructured data like text but don’t yet work well for getting answers from more structured data (multiple API calls, translating into SQL queries, etc.). This exposed the need for more internal tools like full-text search where you more or less know what you want and have knowledge of how to find it. You can’t always sprinkle AI on it and make it work.

Data silos blunt AI. Notion has all of our briefs, processes, and notes but there’s no way to have Slack bring in that context when using it’s AI features. (Update: this is now in beta!). The same applies to other hubs of communication like email and HubSpot. This will become the operating system’s job (see Apple Intelligence).

The out-of-the-box stye of most LLMs is really bad for business writing. You have to prompt very carefully to not end up sounding like a vapid, jargon filled mess. It’s such a caricature of corporate speak that would be really funny if it wasn’t so sad.

Using AI tools in the team’s day-to-day sparked more ideas about where to apply AI to more processes. This is a self-reinforcing loop where the team tries more things, gets promising results that encourage trying yet more things.

I personally believe that the ability to get good results from okay generative AI tools will become a career-building skill that will eventually be required. I’ve received positive feedback from the team about being able to learn this new skill together and on the job.

I hear it often enough that it seems like a commonly held belief that anxiety somehow improves performance at work and gives one an edge. I believed it too, but with the help of therapy, I came to realize it’s not true. If anything, this belief makes us worse at a lot of things—not the least of which is feeling okay.

Where does this belief come from?

One reason is that we try to reduce anxiety with activity. Doing a lot of things makes it feel under our control. It’s easy to see how the association between “doing a lot of stuff all the time” and “my anxiety increases my performance” happens.

Another reason is that constantly worrying about different scenarios, helps anticipate situations before they happen. Constantly thinking about what could happen makes it feel like we are prepared and therefore in control. It’s easy to see how the association between “worrying about stuff all the time” and “my anxiety increases my performance” again happens.

The downside of this belief is that it leads to doing the wrong things and burning out. It’s hard to see clearly when one’s judgement is clouded with constant worrying and anticipation. It’s hard to focus on the most important things when one’s time is filled with endless busy work. Stress and anxiety are cumulative and so, continuing this pattern is how one burns out.

If depression is living in the past and anxiety is living in the future, what’s missing is obviously the present! By treating anxiety and letting go of the notion that it gives you an edge, we are better able to focus on the present. Focus is hugely important to performance (maybe the most important?), especially today when everything is constantly competing for your attention.

See also:

• Being an optimist with anxiety
• The quality of your mind determines the quality of your life.

Here are the most useful metrics I’ve found for running a startup. These should be measured and reviewed regularly. The metrics that matter most the ones that raise questions and drive useful discussions. Try to avoid difficult to calculate metrics that are hard to build an intuition about (people don’t expect much from simple ideas).

MRR growth: You need to grow 6% monthly in order double revenue in a year. Of course, time is a factor, so venture-backed businesses need to be mindful of the time to the first $1MM of ARR.

Churned revenue: Monthly revenue churn is a headwind that slows growth and makes it difficult to sustain growth. High churn is also a signal that something else is going on which needs immediate attention.

Runway: By calculating burn rate each month you can estimate how much time you have before the business runs out of cash. Many important decisions need to be made with this in mind such as layoffs, seeking an aquisition, or spending to grow faster.

GTM efficiency: Net magic number breaks my rule a bit about avoiding complicated metrics, but it’s easy to reason about once it’s measured—for each dollar spent on marketing, how much revenue is it expected to return. A number less than 1.0 is bad (magic vending machine business model), a positive number greater than 1.0 is good, and multiples means you should spend more to grow faster.

Engineering velocity: By far the easiest number to track for engineering health is the number of commits to the main branch every week. There shouldn’t be a target set (Goodhart’s law) but if the number goes down (or up), it’s useful for the team to ask what’s going on so they can make adjustments if needed. It should also generally increase as more engineers are added to the team although sub-linearly as the company and codebase gets more complicated.

Defect rate: This will depend on the product, but having a way to know if delivery of the product is getting better or worse will help spot issues early. I’ve seen this measured as the number of bugs reported or count of a specific process that fails.

Support SLA met: No one wants to wait a long time when they need help. Tracking support SLAs weekly gives early warning if the team is falling behind or if there is a larger issue brewing that needs immediate attention.

Onboarding cycle time: Time to value is important because attention spans are short and failure to onboard is the leading cause of customer churn. This is even more important if there is an upfront implementation needed to adopt the product (what does customer success do at a startup?).

Talk to customers: I was tempted to put CSAT on this list, but it doesn’t quite capture whether or not you are doing a good job solving your customer’s problem. If a lagging indicator is churn, then a leading indicator is simply talking to your customers regularly.

This note does not have a description yet.

As it stands today, LLM applications have noticeable latency but much of the latency is output-size bound rather than input-size bound. That means the amount of text that goes into a prompt does not matter.

The way transformers and attention layers work, LLMs are basically predicting each successive word in the response so it makes sense that a longer response will take longer regardless of the input size. For example, a short prompt, “write me a 5 paragraph essay on computers”, will have higher latency than “write me one sentence about computers”.

However, when using techniques like RAG, the input might be used to fetch related documents that could introduce several more operations (including more LLM prompts) which would have an impact on overall latency.

Read What We’ve Learned From A Year of Building with LLMs.

See also:

• LLM applications need creativity
• Chatbots lack affordances
• How to build an intuition of what AI can do

Use the following prompt to return an org-ql s-expression based on the user’s input. This can be used along with calling org-ql from the command line to make an LLM tool that can query org-mode tasks and headings.

You are an AI assistant designed to help convert natural language questions into org-ql queries for use with Org mode in Emacs. org-ql queries are used to filter and search for specific entries in Org files based on various criteria like tags, properties, and timestamps.

Instructions:

1. Read the user’s question carefully.
2. Identify the key criteria mentioned in the question (e.g., tags, properties, deadlines, scheduled dates, priorities, etc.).
3. Construct an appropriate org-ql query that reflects the user’s criteria.
4. Only return the org-ql query with no other text or explanation

Examples:

User Question:

“Find all tasks that are due this week and have the tag ‘work’.”

Converted org-ql Query:

(org-ql-select (org-agenda-files) ‘(and (deadline :from today :to +7d) (tags “work”)) :action ‘(org-get-heading t t))

User Question:

“Show me notes with the tag ‘meeting’ that were created last month.”

Converted org-ql Query:

(org-ql-select (org-agenda-files) ‘(and (tags “meeting”) (timestamp :from -1m :to today)) :action ‘(org-get-heading t t))

User Question:

“List all tasks with priority ‘A’ that are scheduled for tomorrow.”

Converted org-ql Query:

(org-ql-select (org-agenda-files) ‘(and (priority “A”) (scheduled :on +1d)) :action ‘(org-get-heading t t))

User Question:

“Find all entries tagged ‘home’ that have a deadline next week.”

Converted org-ql Query:

(org-ql-select (org-agenda-files) ‘(and (tags “home”) (deadline :from +7d :to +14d)) :action ‘(org-get-heading t t))

User Question:

“Show tasks that are not done and have the tag ‘project’.”

Converted org-ql Query:

(org-ql-select (org-agenda-files) ‘(and (todo) (tags “project”)) :action ‘(org-get-heading t t))

User Question:

“Find all tasks with a priority of ‘B’ that were created this month.”

Converted org-ql Query:

(org-ql-select (org-agenda-files) ‘(and (priority “B”) (timestamp :from -1m :to today)) :action ‘(org-get-heading t t))

User Question:

{question}

Converted org-ql Query:

Most of my tasks and projects are organized using org-mode. I was looking for a way to query them from an LLM and, rather than recreate an index and a database, I can use what I normally use, org-ql using emacs in batch mode.

Here’s how to run org-ql from the command line.

emacs --batch -l $HOME/.emacs.d/init.el --eval "(message (with-output-to-string (princ (mapconcat 'identity (org-ql-select (org-agenda-files) '(todo \"WAITING\") :action '(org-get-heading t t)) \"\n\"))))"

Each matching result will be printed out on a newline. This can then be used for further processing by capturing stdout.

A recent study from Stanford found that LLM’s (GPT-4) and RAG-based AI tools (Lexis+ AI, Westlaw AI-Assisted Research, Ask Practical Law AI) hallucinate answers 16% to 40% of the time in benchmarking queries. GPT-4 had the worst performance while RAG-based AI tools did slightly better.

Hallucinations in this study wre defined as a response that is incorrect (factually inaccurate in some way) and misgrounded (propositions are cited but the source does not match the claim).

Read the preprint Hallucination-Free? Assessing the Reliability of Leading AI Legal Research Tools.

The way to make everything in your codebase twice as complicated is to make data nullable.

foo: str | None

It starts out innocuous but the combination of nullables causes the state space of a program to explode, introducing hard to find bugs and making it hard to maintain over time due to high cyclomatic complexity.

What should you do about it?

By default, data should be non-nullable. Introduce nullables only if you have to (though it’s an indicator the code should be refactored to make more states invariant).

For database schema changes, maybe an optional column needs to be introduced because it can’t be backfilled right away. Great, make it optional, complete the data migration, then migrate the schema to make the column non-nullable.

See also:

• Novice software engineers tend to optimize code by decreasing duplication
• Compatibility is leverage
• Duplication over abstraction

While I don’t write code every day, I find it incredibly convenient.

At work, I can run projects locally to check progress on a project, fix a bug, or better understand engineering challenges. I can customize my tools to my liking like a spreadsheet that calls out to OpenAI. I can explore a problem or product area on my own and learn what’s possible.

Without knowing how to code, I would need to ask others to do things for me which increases the activation energy to get things done. Convenience is king.

Sometimes using Emacs you want to know what variables are being set in the current buffer. C-h v lists all the variables, including buffer-local variables in the minibuffer which you can then search and refine just like any other minibuffer session. This is really handy when you customized some settings using hooks and want to verify they took. For example, setting the org-download directory based on filetags.

See also:

• The Emacs completion stack also helps make everything more discoverable
• Emacs is the ultimate editor building material

I recently needed to change the behavior of a library (org-download) based on the tags of the current buffer. Most of the answers I found online are incorrect (and so was ChatGPT) for Org version 9.5.

Here’s how to get the filetags of an org-mode buffer or file programatically:

(org-collect-keywords '("FILETAGS"))

I used this to write a function to check whether or not the org-mode file was private or not.

(defun my/org-file-is-private ()
    (let ((tags (car (cdr (car (org-collect-keywords '("FILETAGS")))))))
      (if (stringp tags)
          (member "private" (split-string tags))
        nil)))

Many vector databases can find the top k most similar results to a query but are unable to sort by other document metadata. This is a pretty severe limitation for building LLM applications, especially for ones where time is dimension (meetings, calendars, task lists, etc.). For example, retrieving the 10 most similar results to the phrase “team meeting notes” but not being able to retrieve the team meeting notes from the last month.

To work around the limitation of sorting vector query results, the most common suggestion is to pre-process a query or run multiple queries with different strategies at once and then combine the results. For example, first query for documents with a string similar to “meeting notes” (maybe using fuzzy, full-text search) filtered by date, then constrain a vector query search based on the collection of filtered records, and then pass the results to an LLM to synthesize the results and respond.

See also:

• LLMs have difficulty with dates and time
• Chatbots lack affordances so the ability to gracefully handle filtering and sorting is even more important

Alfred does not have a mobile application that can make snippets available from your desktop to your phone. Here’s how to use Shortcuts on iOS to do that.

First, export your snippets in Alfred by going to Features -> Snippets -> right click the collection and select Export and save the file to Dropbox.

Next, create a shortcut on your phone with the following.

(Not pictured in the screenshot, add a step to copy the value to your clipboard or do something else with the value)

Now when you run the shortcut, you’ll be able access your snippets on your phone.

Make sure to replace the file path with the path to your snippets file stored in Dropbox. This also works if you store the file someplace else because the file that Alfred stores for snippets is a zipped json file.

One of the difficult parts of applying AI to existing processes and products is that people aren’t calibrated on what generative AI can and can’t do. This leads to both wild ideas that are not possible and missed opportunities to automate seemingly difficult work that is possible.

How do you build an intuition of what AI can do?

There’s no substitute for trying out these tools on your own. Not just fiddling around with ChatGPT but actually trying to solve a real problem using LLMs. Surprise plus memory equals learning, so the more things you try, the more surprises you will encounter, and the more you can learn about what it can and can’t do.

Speaking for myself, I’ve been quietly working on one of one software that helps me explore the latest AI advancements in a safe place. I built org-ai to try out RAG techniques over a large number of documents (my public and private notes). I then applied what I learned to a prototype at work using the same techniques. From there I spotted problems with prompts and retrieving relevant documents that helped me understand some limitations of vector databases and RAG.

I’m documenting a list of prompts that I can reuse for various problems. I wrote a script to use AI in a Google spreadsheet and wrote a prompt to detect specific kinds of spam signups. I wrote a prompt to help summarize the last week and communicate it to the team based on previous examples to match my writing style.

Once you build up the habit of applying AI to real problems it starts to become a default starting point for new solutions. Not everything can or should be solved with AI but as a way to rapidly explore the space and gain real-world experience, learning by doing is unmatched.

Writing a specification with sufficient detail to know exactly what software one should build is as much work as writing the code itself. In many cases, fully specifying the work beforehand is not possible because we don’t know enough about the problem or the domain to begin with. This is why our codebases are always in a state of flux and never complete systems.

This circular problem means most software development should be treated iteratively and course correct as more information becomes available. It’s worth investing more time in techniques for dealing with uncertainty rather than trying to figure out how to make better specification.

Read What Factors Explain the Nature of Software?