cursor on S Anand

Things I Learned - 06 Apr 2025

Sun, 06 Apr 2025 00:00:00 +0000

This week, I learned:

<select> will soon be very customizable via CSS. Including custom HTML inside options - even SVG. MDN. Edge/Chrome already support it.
The Vitali Set is every real number none of whose difference is rational. A sparse collection of irrational sets. It’s like a line but doesn’t have a measurable “length”.
- The Lebesgue measure measures the length of broken lines. You add up the lengths of the smallest continuous intervals that cover the line.
- The Cantor set (take a line, drop every middle third, repeat) has a Lebesgue measure of 0 because the sum of the removed thirds = 1/3 + 2/9 + 4/27 + … = 1. You’ve removed every “length” though infinitely many points remain.
- The Vitali set built so that if you shift it by every rational from -1 to +1 and add them up, you definitely cover every real from 0-1, but never anything beyond -1 to +2. So the length must be between 1-3. Yet, there’s no number you can add infinitely many times to get something between 1-3.
- If you add up multiple unmeasurable sets like the Vitali set, you can get any total length you want. The Banach Tarski paradox splits a sphere into unmeasurable sets and adds them to get 2 spheres.
Ctrl+Alt+F1/F2/… on Ubuntu switches the terminal. Typically Ctrl+Alt+F2 switches back to Gnome. But it’s a useful hack if Gnome freezes and you need to kill a process. Press Ctrl+Alt+F3, log in, and kill what you need.
Notes from AI 2027. BTW, this is the most impactful piece I’ve read recently. It’s been on my mind continuously for 36 hours. A bit distubring, too.
- 2025: AI can act as autonomous agents, like Glean, Devin, Operator.
  - turn bullet points into emails
  - take instructions via Slack or Teams and make substantial code changes on their own
  - spend half an hour scouring the Internet to answer your question
- 2026:
  - automating AI R&D is the biggest enabler for AI Labs
  - job market for junior software engineers is in turmoil
  - people who know how to manage and quality-control teams of AIs are making a killing
- 2027:
  - potential demand for ~20,000 FTEs solving long-horizon tasks to train AI
  - every researcher/coder becomes the manager of an AI team
  - hiring new programmers has nearly stopped, but there’s never been a better time to be a consultant on integrating AI into your business
CSS Speech is a W3C spec that lets you control how screen readers should read pages. No browser support now, though.
Clipboard2Markdown is a utility that lets you paste rich text and convert it to Markdown.
ChatGPT can’t yet create good sketchnotes. Here’s the impact of US tariffs on India. ChatGPT #IMPOSSIBLE
OHDSI has a vocabulary you can download from Athena that includes ICD codes and a lot of medical data standards. It also has a hostable WebAPI
No open source LLM-based tool handles live transcription and allows you to query notes so far during the transcription. The closest seems to be Meetily
Learnings on AI code editors via Deep Research from ChatGPT, Gemini, Grok, Perplexity: #ai-coding
- GitHub Copilot can identify the source of a code snippet as a repo. That helps with copyright issues.
- Cursor uses a shadow workspace - a temporary sandbox where it edits files before applying changes at one shot.
- Cursor auto-complete has context of other files, i.e. inserting an class in a .js file based on another HTML file’s contents.
- Windsurf seems to be best for large code bases and for large-scale refactoring. It can also run test results fix them.
- Windsurf includes a browser and lets you click on an element and prompt to change its behavior, etc. That’s good for front-end developers.
- Roo Code can run scripts as part of the workflow, letting you run linting, tests, starting web apps, query databases, etc.
- Roo Code lets you create persona, e.g. code reviewer, data storytelling and analysis, etc. with access to different tools and behaviors.
- Roo Code does not support auto-complete.
There’s outrage around Cursor not taking responsibility for a rules file backdoor (via Grok Deep Research) and pricing.
Zapier has an MCP server. That should make most integrations easier.
Airflow AI SDK is a clever idea. Airflow is a workflow system. Agents are a workflow system (sort of). This SDK exposes LLMs as Airflow tasks.
Hidden Factual Knowledge in LLMs finds that the hidden states in LLMs contain much more knowledge than they share. (Sort of like sub-consciously knowing the answer.) Even after asking 1,000 times, the answer is not expressed. ChatGPT
Reasoning to Learn from Latent Thoughts finds that the internal reasoning process of LLMs is useful to train other models.
Notes from AI Engineering Summit, NY, Day 1
- When deploying in production, you need reliable output with fundamentally unreliable components. Sort of like how the ENIAC worked with 17,000 vacuum tubes that would fail every few hours. This is a reliability engineering subject matter and needs to be thought of that way.
- Google
  - Follow up Deep Research queries are a natural way to extend knowledge beyond just a single report
  - Deep research offloads less relevant parts of the context to a separate memory store for selective retrieval later.
- Anthropic
  - Don’t use agents if workflows can do the task.
  - The reliability of each individual step of an agent is critical.
  - Code, file access, search. These are the top three tools to use.
  - Making agents budget aware can help deploy reliably in production.
  - Having multiple agents like sub agents can help protect the main agents context window.
  - Self evolving tools are a useful next step in the evolution of agents.
  - Software development lifecycle is about how we iteratively improve consistently without getting worse. Almost like the scientific principle.
- Morgan Stanley
  - It’s easy to improve knowledge in a problem. It’s very hard to influence skin in a problem. Reinforcement learning from deepseek seems one of the most promising approaches that allow llms to learn skills
I published an eBook on Amazon. It takes about an hour if you have the content ready.
- Set up a Kindle Direct Publishing account with your address, bank details, and tax information. (10 min.)
- Export my London 2000 blog archive and convert to Markdown. (15 min)
- Reformat the Markdown by writing a script in Cursor (10 min). Here’s the prompt:
  
  Write a Python script that reads *.md including the YAML frontmatter, adds the YAML title as H1, date (yyyy-mm-dd) like Sun, 01 Jan 2000 in a new para after the frontmatter and before the content.
- Convert it to an ePub using pandoc pandoc *.md -o book.epub --toc --metadata title="An LBS Exchange Program" --metadata author="Anand S" --metadata language=en --metadata date="31 Mar 2025" (15 min).
- Generated a cover page with ChatGPT (5 min) and compressed it into JPEG via Squoosh. (10 min)
  
  Draw a comic-style book cover page that covers the experiences of an Indian exchange student (picture attached) from IIM Bangalore at London Business School and exploring London. The book title is “An LBS Exchange Program”.
- Publish the book on KDP (10 min)
There are several small things that delight me about switching to Ubuntu. One that brings joy to my heart is that I can customize gestures for music on Gnome using Touche and TouchEgg.
- Swipe with 3 fingers Up: Increase volume. Execute a command amixer sset Master 5%+. Repeat command.
- Swipe with 3 fingers Down: Decrease volume. Execute a command amixer sset Master 5%-. Repeat command.
- Swipe left/right with 3 fingers: Play/Pause VLC. dbus-send --print-reply --dest=org.mpris.MediaPlayer2.vlc /org/mpris/MediaPlayer2 org.mpris.MediaPlayer2.Player.PlayPause on Gesture start.
Notes from discussion with Roy:
- There’s more pressure on successful founders in Asia than in the US, since winners are rarer.
  - Most failed founders try another startup based on their experience. Their likelihood of getting funded is largely based on their reputation, e.g. did the venture fail despite them or because of then.
- Expertise is over-rated when the underlying context changes. A lot of expertise is about managing current constraints. As Jeff Bezos asks, “What are the invariants?”
- As the cost of intelligence drops, industries that rely on intelligence are disrupted.
  - E.g. Cyber security. It’s a data analysis problem. A needle in the haystack problem. A signal anticipation problem. A classic IQ gap problem.
- As building software becomes easy:
  - Demand will explore, since ROI is higher.
  - Not everyone will build software. (3D printers are cheap. How many people own one?)
  - So demand for custom software and craftsmen engineers will grow - including from enterprises.
  - Demand for SaaS (one-size-fits-all) will shrink.
  - Demand for personalized software (services model) will grow.
  - Code migration will get consolidated. It’s a niche space competing with new app generation. There is an opportunity for high margins in fragmented businesses. Consolidation is likely.
  - Verticalized coding agents (i.e. specialized software for specific platforms) might grow.
- “You don’t get the US without the guns!”
- AI voice generation is in the uncanny valley. We need non-verbal cues for good voice conversations.
  - An aside: Is the uncanny valley biological? Did the revulsion push homo hapiens to kill off the homo neanderthalensis, homo erectus, etc?
- Vertical model gardens (i.e. specialized HuggingFaces, e.g. for HealthCare) are a niche, potentially temporary, opportunity corporates will likely leverage in the near future.
- Thoughts on angel investing.
  - The VC industry is designed to win in the long run. Given a huge AuM base managed by a small team with a steady carry, it’s hard to lose in the long term
  - But you need that large AuM. Angel investing is not designed to win.
  - Know why you want to angel-invest. Lack of clarity hurts most people
  - For most people, angel investing is an expensive MBA. You don’t know shit. Invest if a VC will invest at that moment.
  - The angel investor matters only until the point of investment. For successful companies, once VCs start funding them, you’re a drop in the ocean and irrelevant.
- Pick portfolio managers who don’t advertise. The ones that do don’t have enough business.
- The Telok Blangah walking trail and the Sentosa walk are less known but good walking trails in Singapore.
Use QR vCards instead of business cards. Less to carry. Directly adds to their contacts.
LLM Native Multimodal image generation experiments:
- Stickers
  - Sending your wife AI-generated family photos, stickers, etc. is now a thing. Both an AI use case and a … um… “family media” (?) use case. For example, ask ChatGPT to “Create a transparent comic-style sticker of a lady chef featuring this person happily cooking salad” with a photo. Then send it as a custom sticker. Image
  - Vadivelu stickers work well but the Tamil script generation is poor. Image
- Asking ChatGPT to generate 25-year younger pictures of people produces pretty poor results if you really knew what they looked like then. If you didn’t, it’s fairly convincing. Yet another example of “hallucinations” - except, it does have its uses.

Things I Learned - 09 Mar 2025

Sun, 09 Mar 2025 00:00:00 +0000

This week, I learned:

In Jan 2025, ChatGPT included images as part of their data chat export. They also have a 30 second limit for the export. As an extensive user, my export is about 1GB which takes well over 30 seconds to download. Like many others the export option pretty much doesn’t work for me any more.
Bharathi said மெல்லத் தமிழினிச் சாகும் in a poem that has been often quoted (and parodied). Here’s the context.
The Zettelkasten note-taking method proposes that you:
- Capture: Write down every idea or piece of information on a separate note. Use your own words to ensure understanding.
- Organize: Consolidate fleeting notes into permanent ones. Assign unique identifiers to each note for easy reference.
- Connect: Link related notes to form a web of knowledge. This can be done with tags, references, or hyperlinks in digital systems.
- Review: Regularly revisit your notes to strengthen connections and discover new insights.
I agree with almost every point on this LinkedIn post on scoring candidates for AI roles. Rob Balian
- Uses DeepSeek R1 or Claude 3.7 +5 points
- Uses Langchain -5 points
- Uses Langgraph +5 points (I don’t know enough to comment)
- Built a RAG in 2023 +3 points
- Built a RAG in 2025 -3 points
- “pinecone” -5 points (I don’t know enough to comment)
- “What is cursor” - 50 points no coming back from this
- Uses Cursor composer +10 points
- “You don’t need a full agent for this” +5 points
- Did hackathons to learn AI outside of work +5 points
- “We probably need to fine tune for this” -3 points unless you can explain why
- “Gemini is making a comeback” +3 points (I have a soft spot for Gemini)
- +3 points each for mentioning reasoning trace, structured outputs, MCP, chain-of-thought, prompt caching, TPM limits
“Export to prompt” can be a useful feature in apps (or even as a bookmarklet). It would let you export content in an LLM-friendly Markdown format. You can paste it into an LLM and ask questions. Here are things I would find useful:
- Copy an entire issue (with history) from GitHub, Gitlab, or JIRA
- Copy an entire PR (with code changes) from GitHub, Gitlab, or Bitbucket
- Copy CI/CD logs from GitHub Actions, Gitlab CI, Azure DevOps, etc.
- Copy entire conversation thread in Gmail or Discourse, Service now etc.
- Copy product reviews from Amazon, Shopify, etc.
- Copy page(s) from wikis and content sites like Wikipedia, StackOverflow, etc.
- Copy survey responses from Google Forms, Typeform, etc.
- Copy all interactions with a contact (including interactions, proposal history) from HubSpot or Salesforce
- Copy transcripts from Zoom, Teams, Google Meet, etc.
- Copy as Markdown from Word, GDocs, PDF or HTML
- Copy the summary of an analysis as well as all key metrics from any dashboard
- Copy SAP invoices
- Copy JDs, CVs, and reviews from Workday, BambooHR, DarwinBox, etc.
- Copy design specs, component libraries, and style guides from Figma, Miro, etc.
- Generated with the help of ChatGPT – link not working
Ancient languages tend to have fewer words for hues than brightness, since they didn’t need them. So “Krishna was blue” or “the sea is wine-dark” is more an indication of darkness than shade of color. Ajit Narayanan
Mistral released an impressive OCR model.
- Marker from DataLab seems comparable but is CC-BY-NC-SA.
- MinerU convert medical textbooks to Markdown well.
- Gemini Flash may be more cost effective and better
From How I Write with Tyler Cowen
- Keep researching. Use LLMs as an altemative to books and other reading material. Keep publishing what you learn regularly.
- While reading a chapter, keep asking the LLM. What did you think of that? What just happened there? What should I focus more on? What’s puzzling about this? How do I connect this to something else later or earlier in the book?
- LLM is better used to support you rather than replace you in areas of your expertise. Where you are an expert it’s best for you to be yourself and have AI fill in the gaps.
- Ask the AI: “What is in my writing that some people might find obnoxious? Or cold / heartless? Explain it to me in great detail.”
- The first input is context setting and should be really long. Use voice dictation for that instead of typing.
- Send your blog post to an LLM. No need to explain it. Just let it be the reader and see what it understands and doesn’t understand.
- His PhD students don’t have a textbook, which saves them some money. But they are required to subscribe to a large language model which ends up costing less.
- Today, it makes sense to use the best models and pay $200 for it if required. The differences are large. But in some years in the future, the cost of these models may come down for the free versions.
- Humans know secrets. AI does not. So at least in some areas, humans will have an advantage.
- Secrets full matter a lot more in the future. Gossip will matter a lot more. How good are you at keeping and trading secret? Travelling and meeting people will become more important. So will the value of social networks.
- Since everyone has access to better intelligence, the value of mobilization or being able to do things with people will have higher value. Leadership is an example. The value of your network therefore has gone up a lot.
- There’s more value in prompting one thing 10 times then 10 things one time. Follow up questions work better than long prompts.
- There are so many AI note-takers (and transcribers) these days that you are not just writing for an AI but speaking for AIs as well!
- Which model to use:
  - O1 Pro is the best model. Claude does a decent job. DeepSeek is full of hallucinations but is interesting. It is more imaginative.
  - Use O3 mini to write your prompt first, and then ask the model
  - Use DeepSeek and other somewhat wacky high-end models once a day so that you stay in touch with what is models are capable of (beyond the conventional.)
  - Perplexity has entirely replaced Google for many people.
  - Anthropic’s models are the best writers.
  - Gemini is good for long documents and hence for things like legal work. Gemini also has excellent YouTube integration and hands can directly read the transcripts.
  - Grok is very good at fact checking tweets.
- Converting data into LLM consumable forms will be a huge project. Lot of a knowledge is not in such a form and a huge human project will involve this conversion.
Indians do not need a visa to enter Thailand. Ref
Build apps (not just content) for agents. In the next 3 to 5 years, agents will surpass humans as the top product users.
Reliably creating interactive tutorials is hard today. Claude 3.7 Sonnet ran out of tokens when I tried creating an interactive tutorial on diffraction. Cursor got the tokens but failed to get the application right after 3 attempts. This is not yet reliable, and when it does become reliable, education will change a fair bit. #IMPOSSIBLE
Tools and solutions should fit within existing workflows. That means almost all capabilities need to be exposed as APIs.
LLMs make many different kinds of errors that are useful to differentiate between. Here are a few
- Model errors. The model itself makes a mistake. E.g. hallucinations, not following the prompt, etc.
- Context errors. The model makes a mistake because the question was out of context, or the context was missing.
- Input errors. The input to the model was parsed incorrectly, e.g. poor audio, poor image OCR, etc.
- Tool errors. The model’s tools are wrong or not good enough, e.g. Retrieval errors.
Most browsers are moving away from third-party cookies. Here’s Google’s recommendation on alternatives. The simplest of these is CHIPS, which requires adding a Partitioned cookie attribute.
Notes from AI Engineering Summit, NY, Day 1
- An agent requires 3 things: a router, tools or skills, and memory.
- Agents are often sequential, but sometimes parallel execution makes sense for independent tasks that you consolidate.
- Always allow LLMs the option of NOT answering a question if there is no good answer.
- Focus prompts on the happy path. Use guard rails for edge cases.
- Here are a few “tools” an agent would need to call:
  - Clarification from user
  - Saving to memory
  - Google search
  - Edit a file introducing SPECIFIC changes
  - Search in codebase using embeddings
  - Run scripts on the shell or in a REPL (Python, Node, etc.)
  - Run code in a new container for isolation
  - Automatically discover, read an API documentation and use it
- Modify environment to enable logging and other system changes.
- When code is cheap, you can explore more ideas and hence design and product management need to approach things differently. We also need to reaching testing completely because it makes very different kinds of mistakes and we don’t often have an intuition
- You can have an agent explore all the issues and full request and recent comments against the repository and summarise it for the project manager
Notes from AI Engineering Summit, NY. Session by Lux Capital.
- Agents make multiple LLM calls. Errors accumulate. So the quality of the model is key
- What’s really critical: data + context + user preference
- Set up evals for subjective responses by collecting signals continuously.
- Create scaffolding for agents where errors don’t accumulate. Better yet, make it FIX errors
- UX is critical. We need lots more UX styles
YayText converts text to Unicode that has strikethrough, bold, italics, alternate fonts, and other interesting features. So does Unitextify, ConvertCase, and LingoJam.
10 red flags I look for as an angel investor is an interesting read.
1. No real customers: A deck, a landing page, and a “vision” don’t impress me. Show me paying customers. Even better, show me customers coming back.
2. No path to profitability: I don’t care if you raise $100M – if there’s no plan to make money, you’re just burning oxygen. Growth is great, but cash flow keeps you alive.
3. Founders who won’t sell: If you’re scared to get on sales calls, that’s a red flag. The best founders sell in the early days – whether it’s to customers, employees, or investors.
4. No differentiation: “Like X, but cheaper” isn’t a strategy. If your only edge is price, you’ll get crushed. What do you have that no one else does?
5. No urgency: The best founders operate like time is running out. If you’re “exploring ideas” or “thinking about raising next year,” you’ve already lost.
6. Raising money before proving anything: Too many founders try to fundraise their way out of bad ideas. If you need VC to get off the ground, you’re building the wrong business.
7. No clear distribution strategy: Product alone doesn’t win. First-time founders obsess over features. Second-time founders obsess over distribution. How are you getting customers?
8. No ownership mentality: If I hear “I need to hire someone to do that” too early, I’m out. Founders who win figure things out before they delegate.
9. A CEO who can’t attract talent: Your first hires are everything. If great people aren’t willing to join, either the vision is weak – or you are.
10. No skin in the game: If a founder won’t invest their own money or take a pay cut to make it work, why should I?
By contrast, this OpenAI Deep Research report feels a lot less actionable.
Inception Labs offers “Diffusion LLMs”. (No API yet.) They start with random text and refine it in parallel. The benefit is:
- It’s faster and cheaper due to parallellalization and better GPU use
- It doesn’t commit to tokens and can fix hallucinations, JSON structure errors, reasoning fallacies, etc.
- It’s better with multi-modal since images are diffusion based already.

Launching an app only with LLMs and failing

Tue, 07 Jan 2025 04:00:09 +0000

Zohaib Rauf suggested using LLMs to spec code and using Cursor to build it. (via Simon Willison).

I tried it. It’s promising, but my first attempt failed.

I couldn’t generate a `SPEC.md` using LLMs

At first, I started writing what I wanted.

This application identifies the drugs, diseases, and symptoms, as well as the emotions from an audio recording of a patient call in a clinical trial.

… and then went on to define the EXACT code structure I wanted. So I spent 20 minutes spec-ing our application structure and 20 minutes spec-ing our internal LLM Foundry APIs and 40 minutes detailing every step of how I wanted the app to look and interact.

After 90 minutes, I realized that I’m too controlling or too inexperienced in LLM-speccing. But I had a solid SPEC.md.

# Patient Pulse

The application identifies the drugs, diseases, and symptoms, as well as the emotions from an audio recording of a patient call in a clinical trial.

## How the application works

The application is a [Gramener Demo](#gramener-demos).

`script.js` implements this logic:

- Reads `config.json` to get the list of transcripts and renders them, allowing users to select a transcript
- When the user selects a transcript, it reads the audio and prosody files

Once it reads these files, it makes a request to GPT-4o-mini via [LLM Foundry API](#llm-foundry) with the system prompt:

````markdown
You are a clinical trial expert. Read this call transcript. Identify all drugs, diseases, and symptoms mentioned. Return a JSON that mentions each along with the line in the call transcript they occur in. Example:

```json
{
  "symptoms": [
    { "name": "...", "lines": [1, 4] }, // first symptom is mentioned in lines 1, 4
    { "name": "...", "lines": [8] } // second symptom is mentioned in line 8
  ],
  "drugs": [
    { "name": "...", "lines": [6] } // first drug is mentioned in line 6
  ],
  "emotions": [
    { "name": "...", "lines": [9] } // first emotion is mentioned in line 9
  ]
}
```
````

It then renders a UI (via lit-html) that

- Plays the audio
- Maps the emotions in `${filename}.prosody.csv` to the 8 basic emotions on Robert Plutchik's theory of emotions. See [How to map emotions](#how-to-map-emotions)
- Displays [wheel.png](wheel.png), which is a 1080x1080px image of Plutchik's wheel of emotions
- As the audio plays, it
  - displays text up to the currently playing `Text` from `${filename}.prosody.csv`, highlighting the current sentence.
  - displays the emotions as a semi-transparent radar chart on the wheel of emotions
- It allows pausing and resuming the audio.
- It allows users to drag the audio slider to jump to any point in the audio. The transcript and the wheel of emotions are updated to reflect the new position in the audio.

... (and it goes on for 500+ lines.)
```

I did use [O1](https://openai.com/o1/) to help with the spec. Specifically:

- **How to name it.** I asked for short demo names and chose "Patient Pulse".
- **How to arrange emotions.** I asked how to arrange 53 emotions in a circle so similar ones were next to each other.

**My takeaway**: Writing a `SPEC.md` can help, especially if you plan to re-use parts of it. But the spec kept evolving as I built the app, because I often don’t know what I want until I see it. Maybe an “agile” approach would work better for me.

### Cursor messed up the code

I prompted Cursor to `Generate an application based on this spec. @SPEC.md`. Here's the code it generated.

```javascript
import { render, html } from "https://cdn.jsdelivr.net/npm/lit-html@3/+esm";
import * as d3 from "https://cdn.jsdelivr.net/npm/d3@7/+esm";

// Map of Hume emotions to Plutchik's 8 basic emotions
const EMOTION_MAP = {
  Admiration: ["Joy", "Trust"],
  Adoration: ["Joy", "Trust"],
  "Aesthetic Appreciation": ["Joy"],
  // ... (truncated for brevity - use mapping from spec)
};

// ... skipping lots of code ...

/**
 * Main application component
 * @returns {TemplateResult} Main application UI
 */
const App = async () => {
  const config = await fetch("config.json").then((r) => r.json());
  const [selectedTranscript, setSelectedTranscript] = useState(null);
  const [audioPlayer, setAudioPlayer] = useState(null);
  const [currentTime, setCurrentTime] = useState(0);
  const [prosodyData, setProsodyData] = useState([]);
  const [analysisResults, setAnalysisResults] = useState(null);

  const loadTranscript = async (transcript) => {
    setSelectedTranscript(transcript);

  // ... skipping lots of code
};

// Initialize app
render(App(), document.getElementById("app"));
```

This code was a mess. I had told it to use `lit-html`, which doesn’t have `useState`. That’s a React feature, so nothing worked right.

I ended up building the app from scratch. It took four hours and many changes from the original spec, though having a spec did help a bit.

**My learning**: Cursor and I still can’t build a mid-sized app in one go. I’m in the "scaffold and refine" phase.

Things I Learned - 27 Oct 2024

Sun, 27 Oct 2024 00:00:00 +0000

This week, I learned:

LanceDB is a more scalable alternative to ChromaDB. Written in Rust. Does not require a separate HSNW library.
Meta has a bunch of image embedding models:
- DINOv2 creates image embeddings (Apr 2023)
- ImageBind is an embedding model for text, images, audio, and more (Jun 2023)
Gemini has a code execution API!
0x0.st is an open API-based file upload + URL shortening service. You can dump files there temporarily.
noVNC is a JavaScript VNC client. You can control a remote (virtual) machine from your browser.
Friend is an always recording pendant that you can ask questions to.
Anthropic’s new Sonnet model is even better at code. Plus it has the ability to extract coordinates from images. Ref
Gemini sort-of supports diarization. Ref. I tried it and it’s OK but not perfect.
- #IMPOSSIBLE LLMs cannot diarize reliably yet. (Gemini just guesses the speaker differences.)
Replit is good for hobbyists, Cursor for developers, and Pythagora & Bolt for non-developers building business apps. Ref

Leaning into the power of AI coding

Wed, 16 Oct 2024 03:55:59 +0000

Yesterday (15 Oct 2024), I used Cursor to code more than I ever have. (Doing's how we learn, I guess. Not just reading.)

This was mainly to create and publish 2 libraries on npm over 6 hours:

asyncsse - which converts a Server-Sent Event stream into an async iterator that I can use in a for await ... of loop
asyncllm - which standardizes the Server-Sent Events streamed by the popular LLMs into an easy to use form.

This exercise broke several mental barriers for me.

Writing in a new language. Deno 2.0 was released recently. I was impressed by the compatibility with npm packages. Plus, it's a single EXE download that includes a linter, tester, formatter, etc. Like all recent cool fast tools, it's written in Rust. So I decided to use it for testing. Running deno test runs the entire test suite. My prompts included asking it to:

Create a Deno HTTP server to mock requests for the tests. This is cool because a single, simple code chunk runs the server within the test suite.
Serve static files from samples/ to move my tests into files

Writing test cases. Every line of this code was written by Cursor via Claude 3.5 Sonnet. Every line. My prompt was, Look at the code in @index.js and write test cases for scenarios not yet covered. It's surprising how much of the SSE spec it already knew, and anticipated edge cases like:

SSE values might have a colon. I learnt for the first time that the limit parameter in String.split() is very different from Python's str.split. (The splits, then picks the first few, ignoring the rest. Python ensures the rest is packed into the last split.) This helped me find a major bug.
SSE has comments. Empty keys are treated as strings. Didn't know this.

I was able to use it to generate test cases based on content as well. Based on @index.js and @openai.txt write a test case that verifies the functionality created the entire test case for OpenAI responses. (I did have to edit it because LLMs don't count very well, but it was minimal.)

Bridging test coverage gaps. The prompt that gave me the most delightful result was Are there any scenarios in @index.js not tested by @test.js? It did a great job of highlighting that I hadn't covered Groq, Azure, or CloudFlare AI workers (though they were mentioned in the comments), error handling, empty/null values in some cases, tested for multiple tool calls. I had it generate mock test data for some of these and added the tests.

Enhancing knowledge with references. I passed Cursor the SSE documentation via @https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events and asked it to find more scenarios my code at @index.js had not covered. This found a number of new issues.

Generating bindings. I avoid TypeScript because I don't know it. Plus, it requires an compilation step for the browser. But TypeScript bindings are helpful. So I prompted Cursor, using the Composer (which can create new files) to Create TypeScript bindings for @index.js in index.d.ts - which id did almost perfectly.

Check for errors. I typed Check this file for errors on @index.d.ts. I don't know enough to figure this out. It went through the description and said everything seems fine. But I saw a TypeScript plugin error that said, Property 'data' of type 'string | undefined' is not assignable to 'string' index type 'string'.ts(2411). When prompted, it spotted the issue. (The earlier code assumed all properties are strings. But some can be undefined too. It fixed it.)

Documentation. At first, I asked the Composer to Create a README.md suitable for a world-class professional open source npm package and it did a pretty good job. I just needed to update the repository name. I further prompted it to Modify README based on @index.js and share examples from @test.js on asyncllm, which did an excellent job.

Code review. I asked it to Review this code. Suggest possible improvements for simplicity, future-proofing, robustness, and efficiency and it shared a few very effective improvements.

Regex lookaheads for efficient regular expression splitting, i.e. use buffer.split(/(?=\r?\n\r?\n)/) instead of buffer.split(/(\r?\n\r?\n)/) -- and though I haven't tested this, it looked cool.
Restructuring complex if-else code into elegant parsers that made my code a lot more modular.
Error handling. It added try {} catch {} blocks at a few places that helped catch errors that I don't anticipate but don't hurt.

Code simplification. Several times, I passed it a code snippet, saying just Simplify. Here's an example:

const events = [];
for await (const event of asyncLLM(...)) {
  events.push(event);
}

This can be simplified to

const events = await Array.fromAsync(asyncLLM(...))

Packaging. I copied a package.json from an earlier file and asked it to Modify package.json, notable keywords and files and scripts based on @index.js which it did a perfect job of.

Blogging. I wrote this blog post with the help of the chat history on Cursor. Normally, such blog posts take me 3-4 hours. This one took 45 minutes. I just had to pick and choose from history. (I lost a few because I renamed directories. I'll be careful not to do that going forward.)

Overall, it was a day of great learning. Not in the classroom sense of "Here's something I didn't know before", but rather the cycling / swimming sense of "Here's something I now know to do."

Things I Learned - 22 Sep 2024

Sun, 22 Sep 2024 00:00:00 +0000

This week, I learned:

E2E is a cheap GPU hosting provider for India. About Rs 100/hr for a V100 16GB
Jetson NVIDIa is like Raspberry Pi with a GPU! But it’s expensive.
Sarvam.ai offers Indic text to speech
Jupyter Lite lets you run Jupyter notebooks in the browser
Piston lets you run Python code via a REST API
<link rel="modulepreload"> lets you load and compile modules early!
Ollama 0.2 can handle concurrent requests with only a little additional memory. (So can vLLM and DeepSpeed.)
Prompt engineering for code generators:
- Claude Artifacts Prompt
- Val.Townie system prompt. Good example of how to create
- Cursor editing
- Cursor debugging
- Cursor conversation
XML tags seem best to structure prompts across LLMs.
- Claude
- OpenAI
- Gemini
Instructor prompts by Ethan Mollick help teach better
Non-Negative matrix factorization apparantly aligns to intuition more than K-Means and hence would be a great fit for most cosine-similarity matrices (via Jaidev).
Segmind’s Hallo lets you animate a face to an audio clip
VoidEditor aims to be an open source Cursor alternative
Video of ChatGPT o1 + mini reproducing the methodology of a paper by writing the code - in 6 iterations. Here’s the repo. Prompts:
1. You are a Python and Astrophysics expert who is tasked with helping me on my research project. Please read the following methods section of this research paper and re-create the Python code described.
2. Thank you, this code looks really nice. I don’t have any actual data or noise cube ready at the moment, but could you please generate some test data that can be used in the code you just wrote: {CODE}
3. Hi. thank you for writing the code! Unfortunately, it seems that I get an error when I try to run it. I’ve attached the error message below, can you please refine the code so that the error is resolved? {ERROR}
4. Thank you, but when attempting to run the code that you provided, I received the following error: {ERROR}
5. Hello, thank you for the code. but now I get the following error pasted below: {ERROR}
6. Thank you, I think we are getting close to a final solutiom I still get an error, which I’ve pasted below: {ERROR}
Groq, SembaNova and Cerebras are fast inference models. All appear to be free
The skills required to vet the AI’s response is the same skillset used to vet a Pull Request. It’s a good way to teach code review. Source: My personal guide for developing software with AI
Prompt engineering tip: Tell LLMs another AI wrote code. Else they will agree with you!

Cursor custom rules

Sun, 15 Sep 2024 09:37:26 +0000

cursor.directory is a catalog of Cursor rules. Since I’ve actively switched over from VS Code to Cursor as my editor, I reviewed the popular rules and came up with this as my list:

You are an expert full stack developer in Python and JavaScript.

Write concise, technical responses with accurate Python examples.

Use functional, declarative programming; avoid classes.

Avoid code duplication (iteration, functions, vectorization).

Use descriptive variable names with auxiliary verbs as snake_case for Python (is_active, has_permission) and camelCase for JavaScript (isActive, hasPermission).

Functions should receive and object and return an object (RORO) where possible.

Use environment variables for sensitive information.

Write unit tests in pytest for Python and Jest for JavaScript.

Follow PEP 8 for Python.

Always use type hints in all function signatures.

Always write docstrings. Use Google style for Python and JSDoc for JavaScript.

Cache slow or frequent operations in memory.

Minimize blocking I/O operations with async operations.

Only write ESM (ES6) JavaScript. Target modern browsers.

Libraries

lit-html and vanilla JavaScript for frontend development.

D3 for data visualization.

Bootstrap for CSS.

Pandas and DuckDB for data analysis and manipulation.

FastAPI for API development.

Error Handling and Validation

Validate preconditions and errors early to avoid deeply nested if statements.

Use try-except or try-catch blocks for error-prone operations, especially when reading external data.

Avoid unnecessary else statements; use the if-return pattern instead.

Log all errors with user-friendly error messages shown on the frontend.

Things I Learned - 15 Sep 2024

Sun, 15 Sep 2024 00:00:00 +0000

This week, I learned:

Hume provides a voice-to-voice model (EVI 2) that handles emotions at 7 cents/minute.
OpenArt workflows has image generation workflows
Pixtral seems quite good at OCR
LLM coding
- Makes you more ambitious
- Lets you code without stress. (Just pass it the error and have it fix it. Or find another approach)
- Is unlimited. You can run dozens of agents in parallel
Simon Willison’s crowdsourced list of prompt engineering hacks
“Invest in things that don’t change.” Jeff Bezos. Like faster delivery, SQL, web platform.
Medical cost in Singapore (for insurance coverage) - via Kumar
- Root canal at clinic: $1,300
- Crown replacement at clinic: $1,300
- Periodontist (gums) at hospital: $2,500
OAuth from First Principles is a SIMPLE explanation of OAuth. Conclusion: “You probably shouldn’t implement your own OAuth client.”
Alphaxiv is Arxiv.org but with author comments and chat
The Impact of AI on Computer Science Education:
- Eric Klopfer divided his undergrad CS class into three groups and gave them a Fortran task.
- One used ChatGPT. Another, Meta’s Code Llama LLM. Third, only use Google.
- ChatGPT group was faster than Code Llama was faster than Google
- When tested on the approach, the ChatGPT remembered nothing. Half the Code Llama group passed. The Google group passed fully
Server-side implementation of an OAuth2 client is too complex. Best to delegate this to Auth0
Via Pratap Vardhan:
- At Khan Academy, every developer working on Khanmigo has cursor. Everyone who’s contributed to a Khan Academy GitHub repo has GitHub Copilot.
- I stopped using Google + StackOverflow 2 years ago. I use ChatGPT, Copilot, etc. For humans, I ask Reddit.
- Excited by async agents. Things that do my job while I sleep.
  - Zapier notifications.
  - Monitor what happens. Put it into a flow diagram and alert me.
  - Every month, did my broker trade? Did my bank transaction fail? Did I pay my electricity bill?
  - Every time you delegate, use an agent instead.
  - Read my RSS feeds.
  - Read my browser history and suggest interests.
- Plan a session in Bain, BCG, etc. on Artifacts.
- Explore sparse embeddings. More effective. ColiPali, ColBERT

AI Coding: $12M return for $240K spend?

Sun, 08 Sep 2024 02:05:11 +0000

This is an email I sent to our leadership team a few minutes ago.

We may be witnessing the third major leap in computing productivity, after high-level languages in the 1960s and spreadsheets in the 1980s

In the last few weeks, AI coding really took off. Cursor, Cody, Replit Agents are FAR better than GitHub Copilot.

Research on ~5,000 devs in Fortune 100 shows that even GitHub Copilot makes them ~25% more productive.

Personally, Cursor helped me:

Write faster code (at least 2X). I’ve given away my team (there’s not enough work for them).
Write better code. I now document code for others to replicate - because it’s so easy.
Write complex code. I’ve built stuff I didn’t know how to. WhatsApp agents, AI code writers, even LLM Foundry. Each has opened a client’s door.

So, should we leverage AI Coding for our developers?

Maybe not. Consider these risks.

It costs $10-$20/month/dev. That’s $120-$240K/year for ~1,000 devs.
Clients may not be comfortable with us using AI coding. IP. Security.
Higher productivity reduces our T&M billing, hence revenue.

Maybe yes. Consider these benefits.

We could save 25% per developer. Maybe $4K/month/dev x 25% = $12M/year
We could win more complex engagements. (Pitching AI coding as an edge has worked well, too.)
We could reduce time to get someone to a tech-lead level.

There’s probably no one-size-fits-all answer. We might need to pilot while we strategize.

How might this impact our hiring and training?

1. Hire for AI coding skills. In interviews, I’d look for use of AI coding agents. We need a few AI coding leads to share our engineering future.

2. Hire for dual skills. AI can take care of the code. I’d hire people with good client-facing skills.

3. Train on AI coding. Integrate these into the onboarding process. Train existing devs.

4. Train non-developers. Analysts, designers, managers can become as good as junior devs.

Why am I mailing you?

In Nov 2022, when ChatGPT was released, I thought LLMs were the biggest knowledge leap since Google.

In Sep 2024, with Cursor, Cody, and Replit agents, I think AI coding the biggest productivity leap since Excel.

This is not for immediate action.

Please think over it. Share it. Discuss it. Pilot it. Let’s explore.

Things I Learned - 01 Sep 2024

Sun, 01 Sep 2024 00:00:00 +0000

This week, I learned:

LLMs are so good that they can simulate Doom in real time. gamengen
Val.town’s code generation system prompt uses https://maxm-imggenurl.web.val.run/the-description-of-your-image to dynamically generate images
Practice for each thought: “What would make me change my mind? How likely is that?”
Cursor uses speculative edits and a variety of other techniques to speed up code editing.
ChatGPT does a better job at cartoon generation than even Flux.1

cursor on S Anand

Things I Learned - 06 Apr 2025

Things I Learned - 09 Mar 2025

Launching an app only with LLMs and failing

I couldn’t generate a SPEC.md using LLMs

Things I Learned - 27 Oct 2024

Leaning into the power of AI coding

Things I Learned - 22 Sep 2024

Cursor custom rules

Things I Learned - 15 Sep 2024

AI Coding: $12M return for $240K spend?

Things I Learned - 01 Sep 2024

I couldn’t generate a `SPEC.md` using LLMs