The product or service in which, value goes to users first and then, upon capturing a mass audience of users, provides values to suppliers.

An AI agent is an intent-based abstraction that combines LLMs to plan and take action in order produce a desired goal.

AI coding agent in the command line:

• Goose coding AI agent
• Open SWE from LangChain

Who is working on this?

• Sierra Agent OS is a framework for building AI agents
• Enso is a subscription to AI agents that perform various tasks

See also:

• AI employee

Several startups are touting AI employees that you can hire to perform a specific function. Itercom announce Fin, an AI customer service agent and so did Maven AGI. Piper is an AI sales development representative, so is Artisan and 11x. Devin is a software engineer.

Others want to provide the backbone to power AI employees. Lattice announced support to hire and onboard AI employees (then walked it back). Emergence AI and Enso are building a platform to orchestrate AI agents.

Is this a good idea?

Employment as applied to AI falls victim to reasoning by analogy and arbitrarily constrains artificial intelligence into preconceived constructs. AI agents can work 24/7, but many labor laws classify work around service time of a typical 40 hour work week. AI agents aren’t hired they are purchased, but many labor laws dictate hiring practices an employer must follow.

If you take the position of AI as employee, what follows is a debate about personhood. This is doomed to be an unproductive discussion because the capabilities of AI are not what people think they are.

See also:

• AI as employees stokes fears of job loss but automation doesn’t increase unemployment
• The labor market is merging with the SaaS market
• AI as tools is a simpler way to discuss implications of AI
• Another difference with employees and AI agents is how to get results e.g. replacing training with intent-based outcome specification

A common question in product management that always seems to come up is some flavor of: should product managers be technical?

My first job out of college was as a product manager working on B2B software. I was not technical. If you asked me back then, I would say it wasn’t an impedement.

Along the way I changed my mind.

I learned to code and that made me better at product. I started a company and that made me better at product. I did sales and that made me better at product.

It’s not the technical bit that makes you better—there are plenty of engineers that are not good at product!

Learning new areas like engineering, sales, operations etc. makes you more efffective. It increases your ability to reason about different problems. It’s increases your ability to work with different people, customers, and teams. It increases the set of solutions you can apply that is calibrated to reality.

So, should product managers be technical? Yes, but I think we get too caught up in the coding part that we forget it’s really about growing knowledge.

Notes on the video 13 Years of Brutally Honest Business Advice. I reworded and modified things to make sense to me.

1. Sell to the rich Don’t sell to the poor because you need to deliver a very large ratio of value to money. Rich people spend more to get less value. Start with the rich and then, eventually when the product/service is so good, sell to the mass market (poor).

2. Priorities make problems easy Most entrepreneurs don’t run their business without priorities and so they have make very little progress. Setting good priorities makes the most important problems to solve obvious and helps others get things done.

3. Raise your standards You need to be aware of what the best looks like and continue to raise the bar. For example, always hire someone better than you at the job will ensure the company gets better with each new person not worse (Peter Principle).

4. Lots of rules means you have dumb people This one is really a sub-item of the previous. A sign you have the wrong people is you have to write down obvious rules for people to follow. You shouldn’t be spending your time doing that and should instead hire better people.

   (I dislike the oversimplification of “dumb” vs “smart”. It’s much better to think about this as “skill fit” rather than a judgment of intelligence.)

5. Get better not bigger Getting bigger, hiring more, spending more, etc. can cover up many problems. Focus should actually be on getting better and constantly learning and adjusting. You’ll get bigger as a result.

6. Let fires burn You need to spend you time on the things that move the business forward and that’s impossible to do if you have to be the one to always solve every problem.

7. Brand is the most valuable thing you can own Brand is the durable way to get more out of all your marketing efforts. It’s built over a long period of time by making good associations between ideas and companies. Most of what we see this days is personal brand bootstrapping a company brand.

8. Understand inputs and outputs of your business Get to the lowest level of detail about what is holding back the business and fix that then the next thing.

9. Stop looking for hacks The problem with hacks is that they work for a time and then they don’t so you have to find the next thing and the next. The best strategies often don’t change like having really valuable content and product.

10. The best people cost more but are worth it Good people pay for themselves in the amount of impact they have. There are many arbitrage opportunities with talent but people don’t recognize it because they cost more.

11. The obvious thing is the main problem The main problem with the business is often the work you are avoiding not the hundred other things you think you need to do. Usually it’s the thing isn’t good enough.

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