A study of 73,000 NFT collections found that more than 95% had a market cap of zero ether and an estimated 23 million people are holding worthless assets.

Read Remember when NFTs sold for millions of dollars? 95% of the digital collectibles may now be worthless.

See also:

• Trading volume of NFTs fell 97%
• Investment strategies that only work in a bull market
• Growth in tech during the pandemic was not permanent

This note does not have a description yet.

The nice part about ChromaDB is that you can read the tables in SQLite using the new Emacs 29 sqlite-mode. That means there is no other configuration for accessing the database, you can open the sqlite file directly.

I was curious to see what metadata was extracted from an automatic document loader in LangChain. I opened the sqlite file and browsed the metadata directly to see what was available. Nice!

See also:

• Why vector databases are important to AI
• Emacs is the ultimate editor building material

You can turn off sending telemetry data to ChromaDB (now a venture backed startup) when using langchain.

from langchain.vectorstores import Chroma

client_settings = chromadb.config.Settings(
    is_persistent=True,
    persist_directory="mydir",
    anonymized_telemetry=False,
)
return Chroma(
    client_settings=client_settings,
    embedding_function=my_embeddings,
)

ChromaDB is a vector database used for similarity searches on embeddings. It’s extremely easy to use if you are using Python and works well with LangChain.

See also:

• Turn off Chroma telemetry in langchain
• Emacs and ChromaDB

As software grows, patterns and practices naturally evolve. Inevitably, someone comes to the conclusion that a change should happen and code should be migrated to the new thing.

While many agree full rewrites are a bad idea, migrations tend to slip under the radar.

Migrations are mini rewrites and the same caution should be applied.

When you think of migrations as rewrites, you think about the problem differently. Rewrites are an exercise in chunking. The total cost of ownership is not just adding it the first time, but updating all other places for consitency, fixing bugs introduced along the way, and maintaining the new thing forever. Unfortunately, many large scale codebases end up with tech debt because of half completed migrations (probably several because a migration are needed to fix the other partial migration!).

You’ll often hear justifications like, “We can do this gradually” and, “We’ll add this to new code first.” All lies we tell ourselves to do the thing we want.

What can you do about it?

Approach the migration as if it needs to happen all at once in one effort or not at all. This pierces the illusion that future us will have the time and focus to complete the work present us doesn’t do (experience would suggest this is never true unless you absolutely have to).

Don’t accept installment plans, pay the whole thing up front or move on because worse is better.

See also:

• Dependencies are a sneaky way migrations are needed and the default strategy should be to not add more
• Closing the gap between previous technical decisions and the current quality bar is engineering leadership

Marl is the marginal user. The one who represents the broad base of users that drive most product decisions to the lowest common denominator. Attention is short. Intolerance for change is high. When you ask why they dumbed down your favorite consumer app into a sugar coated dopamine factory, it’s probably because of Marl.

We’ve all been Marl at one point in time or another.

The thing people forget is that we are all Marl. The things we think couldn’t possibly apply to us, what we think is designed for a mindless scrolling drone, is us too. We are not always Marl and some might be more Marl than others, but we truly are that way some of the time.

Read The Tyranny of the Marginal User.

According to the Lightspeed sales benchmark report for 2023, win rates decreased for 42% of companies surveyed. The larges decreases happened for initial sale prices of $250k+.

The leading reasons are:

• Lost project funding 58%
• Decided to do nothing 44%
• Went silent 41%
• Decision maker left 25%

See also:

• Running a startup during a recession
• Burn multiples are a way of managing growth efficiently

When it comes to selling an asset, it’s helpful to remember that it only takes two people to make an auction. Auctions result in higher sales prices as it’s not just the value of the thing being purchased, but the dynamics of winning. In the sale of a company for example, it’s not just about buying the company but preventing the other party from getting it.

What’s the lesson? Creating an auction for an asset is clearly better and all you need is two interested parties which is a low enough number that it is always worth the effort.

See also:

• Auctions induce feeling of loss aversion
• Mentioned by Paul Graham on the Tyler Cowen podcast when talking about the art market

In sales, it’s easy to mislead yourself into thinking a sales deal is on track when it’s not. A simple way to know that it’s not is to ask yourself if there is a clear next step that both parties have agreed to. Without it, you won’t close the deal and if you do, it’s probably a nothing sale.

Agreeing to a next step can be as simple as deciding whether to move forward with your solution by the end of next week. There is a clear action and deadline that makes it easy to agree. It also keeps the door open for the lead to ask for more materials or proactively raise that there is someone else you need to meet with.

(I didn’t come up with this but I can’t find the source of where I found it).

See also:

• Founder-led sales
• Sending follow-up emails is closely related—it’s much easier to get a response when you are merely reminding them of what you already agreed to do

A common data consistency issue is writing empty strings to the database. An empty string "" is a perfectly valid text or varchar but is usually not what you want.

Thankfully, Postgres has a way of checking for empty strings that prevent storing bad data. A domain is a reusable way to check a value that looks like this:

create domain content as text check (value != '');

This can be used as the column type when creating a table:

create table posts (
    id         serial       primary key,
    title      content      not null,
);

Now you’ll get a friendly error if you try to save an empty string. If you are using SQLAlchemy, you can specify a database model using a domain too.

Read Check data easily with PostgreSQL domains by Benjamin Sago.

See also:

• Postgres is the most exciting boring technology because of features like this
• Most business problems are data modeling problems

A DRI is a commonly used organizational pattern where one person is directly responsible for the overall outcome of an initiative. This avoids many pitfalls like a tragedy of the commons where responsibility is shared amongst everyone and therefore everyone loses all accountability.

It’s challenging but rewarding. This model relies on individual contributors that have the skills to successfully lead, project manage, communicate, and be effective outside of their own domain. For example, a backend engineer might be the DRI for a product feature that includes UI design and frontend work even though they themselves are not a designer or a frontend engineer. The key is being able to extract the best result from others and work through them.

In my career, I’ve worked with this “DRI model” for many years with mixed results. As a manager, I’ve had to intervene in projects going off the rails (delegation not abdication). The most common complaint I’ve heard about being a DRI is that larger initiatives require project management—widely undervalued by engineers—and needs a lot of coaching and help.

When you see something absurd in the market, it’s helpful to ask, “What’s the trade?” How would you make money from it if it truly is absurd? Oftentimes, it’s not that straightforward and there is more to it than you think. This is a good check against biases and, if you truly believe that something is wrong, would you be willing to make the trade?

Read 15 Lessons From Newfound Research.

See also:

• Psychology overwhelms fundamentals in the short run
• Skepticism and optimism in markets shows us that there are cycles that occur but whether you can spot them is a different story

Every portfolio and every decision can be decomposed into being long something and short something. By weighting one area of the portfolio higher than another, you are short on the underweighted parts of the portfolio.

The same is true for decision-making at a startup. Scarce resources mean you can only invest in a certain number of things at any one time. This portfolio of decisions can be analyzed by thinking about what you are short and long on if that makes sense.

Read 15 Lessons From Newfound Research.

See also:

• What’s the trade?
• The focusing illusion shows us the natural bias towards overestimating the importance of what we pay attention to (being long on something)

Being able to programmatically generate content for search engine optimization is only useful if you have a lot of keywords you can target (thousands) and pages you can generate to rank for them.

For example, Zapier found that they could target long-tail of search engine keywords in the pattern of “{software 1} {software 2} integration”. This is tightly linked to their product which is important so they can convert visitors searching for it. It also means they can a high volume of clicks from each page. Let’s say they have 100 integrations, that means they can generate ~10,000 pages (each combination) and, if each page generates 100 clicks per month, that’s 1,000,000 clicks.

When choosing the best SEO strategy, you can do a Fermi estimate to figure out if your business is going to get enough clicks to make it worth investing in programmatic SEO.

See also:

• How to do keyword research which is important for setting the strategy and understanding if programmatic SEO will be worth it
• How to do SEO

You can use a watch with a dive bezel to track two timezones at onces without a GMT hand. This works because dive bezels typically have markers for every 5 minutes and, since time is base 12, you can calculate the second timezone with simple division.

How does it work?

Turn the dive bezel so that the nib is on the timezone offset hour marker. For example, if you are on Pacific time and you also want to track Eastern time, rotate the bezel so the nib so is on the 3 o’clock marker.

To read the time in the second timezone, look at the hour hand to find the hour marker (as usual), find the corresponding minute located on the dive bezel, then divide by 5. Read the minutes as normal and you have the hour and minutes of the second timezone!

In 2023, the average time between raising a Series A and Series B round increased to 31 months according to Crunchbase. With startup funding falling 67% in 2022, more startups could face a difficult time getting funding. Some predict startups will run out of cash in 2023 with the most fiscally conservative ones run out in 2025 unless conditions change.

See also:

• Running a startup during a recession means having enough runway to get through longer time periods between rounds and adapting to endure
• SaaS benchmarks for Series B
• Startup valution multiples fell from 100 to 39 times ARR in 2023

People tend to think impressive results must come from impressively complicated means and effort. We underestimate the power of simple ideas and overestimate complications.

From How to Take Smart Notes (literature notes).

See also:

• Elegance is a heuristic guide to truth
• Wealth-creation mechanisms are simple
• Clarity is one number
• When things are intensely themselves
• Compounding is simple but unintuitive
• Building high quality things comes from using the product

A book by Sönke Ahrens about taking notes to improve productivity and writing which is incredibly convincing but extremely impractical in describing what to actually do.

Writing smart notes explains a system for note taking using the following process:

1. Read and then rewrite the interesting parts of what you read as short literature notes (not quotes, highlights, or margin scribbling)
2. Write down ideas and short notes as fleeting notes and review them within a day (keep project notes separate)
3. Review and turn the literature notes and fleeting notes into permanent notes
   • Permanent notes should not be a reminder of the thoughts or ideas but the actual thing written down
   • The goal of a permanent not is to maximize the utility within your slip-box (the collection of other permanent notes)—doing this forces you to think about it in relation to other notes which further increases understanding and leads to new ideas or questions
4. Use the act of writing permanent notes to find interesting new questions to answer and to source material for writing new works

While it may sound like a lot, making a habit of writing permanent notes adds up. Luhmann’s slip-box contained 90,000 notes but that’s only six notes a day from when he started until the day he died.

See also:

• Building a note-taking habit and my personal note taking practice
• Zettelkasten and a mind map where nodes are notes
• Tools for networked thought
• Emacs org-mode and org-roam

A blog post from GitHub says that their code assistance tool, Copilot, is behind 46% of developers' code, up from 27%. For Java, that number is 61%.

I might be missing something but this is an astonishing change. In two years, generative AI has fundamentally changed where code comes from. What does it mean if these numbers climb to 90%? Will it impact real productivity or merely shift the effort from writing to prompting and editing?

See also:

• AI multiplies the value of expertise
• AI is the next great interop layer
• Typing fast is thinking with your hands

When negotiating, it’s important to control the frame in which the conversation is happening. The frame constrains what kinds of ideas can be explored and the rules that govern evaluating them. When you step into someone else’s frame in a negotiation, you become bound to the constraints they set.

For example, in a sales call, you might be speaking with a customer about pricing. They might ask why you are charging per employee and what the value is. By responding directly to this question, you inadvertently accept it’s frame (incremental value per employee) and the ideas you share to justify value now need to fit within that frame or it won’t make sense.

In the example situation, if you feel like your position is weaker in that frame, it would be better to pop up a level and establish a new frame that plays to your strengths. “Pricing this way enables us to provide $THING_THEY_WANT for a fraction of the cost of $ALTERNATIVE”.

See also:

• Sometimes an answer is required, not necessarily a good one
• People respond in kind so if you are defensive the other party may press harder to push you into their frame

One of the keys to building great products is to regularly make contact with reality. Ideas rarely survive first contact with users—what we think is good might be completely useless to an actual potential customer. Regular contact with reality insulates you from the illusion of explanatory depth.

Founders tend to get so far ahead of themselves in company building that a popular piece of advice from Paul Graham is to build an initial product a small group of users love.

Product people get this wrong too. It’s easy to think we understand something we don’t and roadmaps/timelines don’t bake in time to be wrong.

See also:

• Good product engineers don’t outsource their thinking and talk to users directly
• Still conjecture is vital to product development and so is having good taste
• Have the willingness to pay conversation early

I started building AI for notes to help me chat with my library of notes. The result of that exploration is org-ai—my one of one software that helps me remember what I’ve previously written, summarize information. Under the hood it uses vector-based similarity search and LLMs and agent-based AI to extract useful information from my zettelkasten in a chat-based interface.

See also:

• Context is needed for practical LLM applications
• How langchain works
• Why vector databases are important to AI

I built org-ai using Python which exposes an AI chat interface through a simple CLI. This makes it a bit clunky when using it from Emacs—I would need to open up an instance of a terminal, activate the virtual environment, and execute the program to start the chat.

Luckily, Emacs is the ultimate editor building material and has a simple way of creating a shell called comint (command interpreter). Following the guide from Comint: Writing your own Command Interpreter, I was able to put together a simple integration that makes interacting with the python-based chat application more native feeling to emacs.

Checkout org-ai-shell