developer-workflow on S Anand

Local context repositories for AI

Fri, 20 Mar 2026 07:12:47 +0530

When people ask me for connections, I share my LinkedIn data and ask them to pick.

This week, three people asked for AI ideas. I shared my local content with AI coding agents and asked them to pick.

STEP 1: Give access to content. I use a Dockerfile and script to isolate coding agents. To give access, I run:

dev.sh -v /home/sanand/code/blog/:/home/sanand/code/blog/:ro \
       -v /home/sanand/code/til:/home/sanand/code/til:ro \
       -v /home/sanand/Dropbox/notes/transcripts:/home/sanand/Dropbox/notes/transcripts:ro

This gives read-only access to my blog, things I learned, transcripts, and I can add more. (My transcripts are private, the rest are public.)

STEP 2: Ask agents to scan content. For example, I ask it to read:

Required blog posts related to LLMs /home/sanand/code/blog/ (especially with the category llms)

Other relevant transcripts /home/sanand/Dropbox/notes/transcripts (especially extracted AI advice at /home/sanand/Dropbox/notes/transcripts/extracts/ai/)

Things I learnt at /home/sanand/code/til/

This makes it explicitly aware of the content and can use it to answer questions.

STEP 3: Help it do better. I often add “Use sub-agents as required”, which reduces the context and lets them run more in parallel. I also point them to post-mortems for tips on scanning content effectively.

STEP 4: Output as JSON. JSON lets me write programs to convert to multiple other formats (e.g. HTML, markdown). I specify the fields I want, how I want them filled, and leave the rest to the agent. Sample output.

This is not a new technique. It’s just context engineering, roughly like:

Connecting ChatGPT/Claude/Gemini/ to Dropbox/Google Drive/… and asking it to read the content.
Enabling web search and asking them to search online.

But I can do this (kind of) safely on my local content and I can also teach it how to scan the content - which is a useful learning.

Next steps:

Add README.md to each directory on how to scan the content effectively.
Think about what content repositories I should add
Explore combining content repositories cleverly (e.g. “Read my blog and apply lessons to my code.”)

AI in SDLC at PyConf

Thu, 19 Mar 2026 14:58:26 +0530

I was at a panel on AI in SDLC at PyConf. Here’s the summary of my advice:

Process

Make AI your entire SDLC loop. Record client calls, feed them to a coding agent to directly build & deploy the solution.
Record your prompts, run post-mortems, and distill them into SKILLS.md files for reuse.

Prompting

Ask AI to make output more reviewable. Don’t waste time reviewing unclear output.
Prefer directional feedback (feeling, emotion, intent) over implementational.
Also give AI freedom to do things its way. Learn from that - you’ll be surprised.

Learning

Prefer interns / outsiders over experts. They don’t slow the process with preconceptions and leverage AI better.
Stop learning what AI does well. Learn what AI fails at - using AI. Keep re-assessing these.

Adoption

Developer using AI are still accountable for their code. (Agents might become accountable in the future.)
Start with new projects: less competition, fewer preconceptions, lower risk.
Start in domains where failure is OK, rather than making AI safe enough for high-risk domains.
Create safe spaces where hallucinations don’t matter and run experiments there to learn what AI can do.
Plan for where AI’ll be a year later. It’s growing very rapidly.

The full details of the panel discussion are at Who Owns the Commit?

Using Codex to improve Codex

Sun, 01 Mar 2026 18:26:13 +0800

Instead of learning and applying new Codex features, I asked it to analyze my sessions and tell me what I’m under-using.

I'd like you to analyze my Codex sessions and help me use Codex better.

sessions/ has all my past Codex sessions.

Search online for the OpenAI Codex release notes for the latest features Codex has introduced and read them - from whatever source you find them.

Then, create a comprehensive catalog of Codex features.

Then, analyze my sessions and see which feature I could have used but didn't and make a comprehensive list.

Then summarize which features I should be using more, how, what the benefits are, and with examples from my sessions.

Document these in one or more Markdown files in this directory. Write scripts as required. Commit as you go.

It did a thorough job of listing all the new features and analyzing my gaps.

Read the full story

Here’s the summary: I’m using new models immediately, but not the new features of Codex. For example:

Parallel execution. Yesterday, I ran ~103 tool calls without the new spawn_agents_on_csv feature from last week, which would have saved a lot of time running in parallel.
Permissions. Last week, I ran a script that asked me for permissions 7 times towards the end. Instead, I could have used /permissions to set early permissions.

The best part is that it could just add a few instructions to my AGENTS.md:

Run multiple independent reads in parallel.
For 20+ tool calls, maintain update_plan throughout.
For long-running commands/tests, delegate via sub-agents and report checkpoints.
If blocked by permissions, ask me concise choices.
If sandbox/config gets in the way, use /permissions and /debug-config early.

Now, the beauty is that the tool optimized itself. I don’t even need to learn how to optimize it!

Rofi vs Kanata

Sun, 01 Mar 2026 15:25:48 +0800

Kanata might be the most useful tool I can’t find a use for.

It’s a cross-platform keyboard mapper. Some cool features:

Make any key a modifier. Ctrl, Shift, Alt, etc. are modifiers. But we can make it so that pressing Space + I/J/K/L maps to Up/Left/Down/Right.
Chords. You can map any sequence of keys to anything else. For example, Alt + G, then C can type git commit -m"Experimenting" [ENTER]. Ctrl + M, then Down, can reduce the music volume by 10%.
Toggles. Double-clicking Caps Lock activates capitalization for the current word, and once you type a non-letter, it turns off. Or double-clicking Ctrl can turn on “gaming mode” where WASD becomes arrow keys, and double-clicking again turns it off.
Tap Dance. Double-clicking left-shift can turn on Caps Lock. Triple-clicking turns it off. Quadruple-clicking …

… and there’s lots more.

Unfortunately, I have not been able to find a single use in practice. My main bottleneck is that I don’t remember the shortcuts. So, instead, I use rofi.

Rofi is a programmable menu launcher. The great thing is that I don’t need to remember stuff. When I map it to keyboard shortcuts, it pops up a menu and I pick what I need.

I use it to:

#1: Open any file or browser tab with Ctrl + Alt + F. This is my most used shortcut. It replaces Everything for files, and Chrome Search Tab with a single shortcut.

#2: Paste any prompt fragment with Ctrl + Alt + P.

This is especially useful when adding a prompt fragment, like Expert Lens in the middle of a prompt, or analyzing call recordings a dozen times a day.

#3: Edit the clipboard with Ctrl + Alt + M (for Markdown).

This is a killer feature. I often use it to:

Copy from email/chat and paste it in ChatGPT as Markdown
Copy from ChatGPT and remove the em-dashes and non-ASCII characters
Convert Markdown to Unicode for LinkedIn
Convert Markdown to rich test for pasting in emails or chat
Creating a ChatGPT / Claude / Google AI mode link from a piece of text
…

I’m still keen to find a use for Kanata, but for now, my use of Rofi will continue to grow.

19 Mar 2026: The Compose key is meant to combine two keystrokes to create a new character - which Kanata offers as a feature with any key.

Voice coding is the new live coding

Sun, 21 Sep 2025 11:18:17 +0000

In Feb 2025 at PyConf Hyderabad, I tried a new slide format: command-line slideshows in bash.

I’ve used this format in more talks since then:

LLMs in the CLI, PyCon Singapore, Jun 2025
Agents in the CLI, Singapore Python User Group, Jul 2025
DuckDB is the new Pandas, PyCon India, Sep 2025

It’s my favorite format. I can demo code without breaking the presentation flow.
It also draws interest. My setup was the top question in my PyCon talk.

In Sep 2025, at PyCon India, I extended the setup for voice typing. talkcode.sh is a Bash pipeline that:

uses ffmpeg to record mic into as 16 kHz mono, voice-optimized .opus
sends audio to Gemini via llm for transcription
uses awk to extract the code fence
uses xclip to copy the code to the clipboard
uses xdotool to paste it back to the original window

# Mic only, 16 kHz mono, voice filtering, fast Opus
ffmpeg -hide_banner -v error \
  -f pulse -i default \
  -ac 1 -ar 16000 \
  -af "highpass=f=100,lowpass=f=6000" \
  -c:a libopus -b:a 16k -vbr on \
  -compression_level 2 -application voip -frame_duration 60 \
  -y "$AUDIO"

# Transcribe, extract the code fence and copy to clipboard
llm -m gemini-2.5-flash -a "$AUDIO" -s "$SYSTEM_TEXT" \
  | tee /dev/tty \
  | awk 'BEGIN{f=0} /```/{f=!f; next} f{buf=buf$0"\n"} END{print buf}' \
  | xclip -selection clipboard

# Bring last window to foreground and paste from clipboard
if [ -n "${ACTIVE_WIN:-}" ]; then
  xdotool windowactivate --sync "$ACTIVE_WIN"
  sleep 0.08
  xdotool key --clearmodifiers ctrl+shift+v
fi

During the workshop, I said, “Which (judicial) bench has the longest pending cases,” and it generated a DuckDB query that, single-shot, ran correctly on the Indian High Court judgements dataset.

But LLMs are slow and break the flow. Here’s how I keep the room engaged:

Dictate, don’t type. Speaking is faster and more engaging. That’s why I built this workflow.
Avoid Alt-Tab. Bring the LLM into your app. Window-switching and copy-paste break focus for you and the audience.
Always stream output. Narrate as it loads. | tee /dev/tty streams while piping.
Answer questions while you wait. Keep a Slido Q&A open and address the top ones while waiting for the LLM.

Meta AI Coding: Using AI to Prompt AI

Wed, 13 Aug 2025 09:43:24 +0000

I’m “meta AI coding” – using an AI code editor to create the prompt for an AI code editor.

Why?

Time. The task is complex. If the LLM (or I) mess up, I don’t want re-work. Review time is a bottleneck.
Cost. Codex is free on my $20 OpenAI plan. Claude Code is ~$1 per chat, so I want value.
Learning. I want to see what a good prompt looks like.

So, I wrote a rough prompt in prompts.md, told Codex:

prompts.md has a prompt under the “# Improve schema” section starting line 294.
This is a prompt that will be passed to Claude Code to implement.
Ask me questions as required and improve the prompt so that the results will be in line with my expectations, one-shot.

Codex answered:

I read the “Improve schema” section. A few specifics need your call so I can produce a single, precise prompt.

Masters vs layouts: Remove masters entirely and keep a layouts[], or remove layouts and keep masters[] with shapes acting as the layout? The bullets conflict.

Shape registry: Confirm .shapes is an object map keyed by id at every level (root, master/layout, slide), not arrays. Ordering via z only?

Merge semantics: Confirm deep-merge precedence root.shapes < mid-level (master/layout).shapes < slide.shapes, by id. For arrays like list.items, replace (not concat)?

Theme flattening: Move theme.colors and theme.fonts to root as colors and fonts, or keep theme but allow root aliases? Which do you prefer?

Back-compat: Keep support for old schema, or drop and add a migration utility (CLI/script) to transform old→new? If keep, how long to maintain?

Version: Bump to version: \"2.0.0\" for the new schema?

Validation: Add a JSON Schema file and validate inputs in slidegen.html() (fast fail)? If yes, filename path e.g., schema/slidegen.schema.json?

Tests and samples: Update all decks in tests/ (incl. shapes-demo.json) and tests/index.html to new schema only?

Overrides removal: Confirm slides[].overrides is removed entirely; all overrides via slides[].shapes only.

Any additional fields to normalize while we’re here (e.g., unify unit, enforce %|px, formalize border props)?

Reply with your choices. I’ll then deliver a single, one-shot prompt for Claude Code with exact schema, merge rules, migration plan, test updates, and acceptance criteria aligned to your coding guidelines.

I replied:

masters versus layouts: I want you to remove masters entirely and keep a layouts[]. There currently are layouts inside masters, move them up to one level.

.shapes is not an object map currently. It SHOULD be an object map keyed by id at every level and not arrays and it should be ordered via z only.

The deep merge precedence that you have listed is correct.

For list.items replacement instead of concatenation is correct.

Since we are flattening the themes, we do not want theme at the root level and we do not want theme.colors/fonts aliases.

We do not want to support old schema.

We do not want to migrate from old schema.

We do not want to bump up the version.

We do not want to create a json schema file.

We do want to update all the tests including shapes-demo.json.

We do want to remove slides.overrides entirely, no other fields to normalize.

If you have any other questions, please ask. Else update prompts.md

Codex gave an output. I reviewed it and sent one more prompt:

Drop the house rules.
Allow the root .bg to be overridden by layouts[].bg to be overridden by slides[].bg – and all the .bg values can be { fille, image, image_fit }
layouts must be an object with the .id as key instead of a field. If any of this is unclear, please ask me. Else update prompts.md.

It finally settled on this remarkable prompt.

This prompt was so clear it was easy to review and easy for Claude Code to follow (no inconsistencies).

I plan to use this technique more. You might want to try it, too.

Wed, 21 May 2025 10:46:00 +0000

“Inferencing” is the new “Compiling!”

I spent a fair bit of today playing Bubble Shooter because Claude spent 10 minutes writing code for an npm package: https://www.npmjs.com/package/saveform and for a bunch of other things.

5-10 minutes is too short a time to do something meaningful. I do wish these LLMs would take less or more time. We’re right now in the zone of bad interruption timing.

How to create a Technical Architecture from code with ChatGPT

Sat, 17 May 2025 02:14:09 +0000

Here’s my current workflow to create technical architecture diagrams from code.

STEP 1: Copy the code

Here’s a one-liner using files-to-prompt to copy all files in the current directory:

fd | xargs uvx files-to-prompt --cxml | xclip -selection clipboard

Or, you can specify individual files:

uvx files-to-prompt --cxml README.md ... | xclip -selection clipboard

STEP 2: Prompt for the a Mermaid diagram

Mermaid is a Markdown charting language. I use this prompt with O4-Mini-High or O3:

Create a Mermaid architecture diagram for the files below.

Make sure that the diagram is rich in visual detail and looks impressive. Use the “neutral” theme. Name nodes and links semantically and label them clearly. Avoid parantheses. Quote subgraph labels. Use apt shape: rect|rounded|stadium|... for nodes. Add suitable emoticons to every node. Style nodes and links with classes most apt for them.

Follow that with a bulleted explanation of the architectural elements that is suitable for adding to a slide.

Finally, double-check the architecture against the codebase and provide a step-by-step validation report.

[PASTE CODE]

STEP 3: Copy the diagram into Mermaid Live Editor

Here’s a sample output that you can paste into a new Mermaid Playground:

%%{init: {'theme':'neutral'}}%%
flowchart TB
  %% Source files
  subgraph "Source Files 📁"
    direction LR
    RT_wr[wrangler.toml 🔧]:::config
    PK_pkg[package.json 📦]:::config
    JS_idx[src/index.js 🖥️]:::code
    JSON_spec[openapi.json 📄]:::assets
    HTML_swagger[swagger.html 📜]:::assets
  end

  %% Build & deploy steps
  subgraph "Build & Deploy 🛠️"
    direction LR
    DEV["npm run dev / wrangler dev ▶️"]:::action
    SECRET["npx wrangler secret put LLMFOUNDRY_TOKEN 🔑"]:::action
    DEPLOY["npm run deploy / wrangler deploy 🚀"]:::action
  end

  %% Runtime environment
  subgraph "Runtime Environment ☁️"
    direction TB
    CF_WORKER["Cloudflare Worker ✨"]:::worker

    subgraph "Request Processing 🔄"
      direction LR
      API_ROUTER["API Router 🔀"]:::logic

      subgraph "Endpoints 🌐"
        EXTRACT["/extract 🚀"]:::endpoint
        OPENAPI["/openapi.json 📄"]:::endpoint
        DOCS["/docs (or /) 📘"]:::endpoint
      end

      subgraph "Handlers 🛠️"
        HANDLE["handleExtract 📝"]:::logic
        SERVE_SPEC["serveOpenApi (spec) 📑"]:::logic
        SERVE_SWAGGER["serveSwaggerUI 🖥️"]:::logic
        NOT_FOUND["404 NotFound ❓"]:::logic
      end
    end

    subgraph "Extraction Flow 🤖"
      PROMPT["createExtractionPrompt 🤔"]:::logic
      GPT_API["LLM Foundry API 🔗"]:::external
    end
  end

  %% Connections
  RT_wr --> CF_WORKER
  PK_pkg --> DEV
  JS_idx --> CF_WORKER
  JSON_spec --> CF_WORKER
  HTML_swagger --> CF_WORKER

  DEV --> CF_WORKER
  SECRET --> CF_WORKER
  DEPLOY --> CF_WORKER

  CF_WORKER --> API_ROUTER
  API_ROUTER --> EXTRACT
  API_ROUTER --> OPENAPI
  API_ROUTER --> DOCS

  EXTRACT --> HANDLE
  OPENAPI --> SERVE_SPEC
  DOCS --> SERVE_SWAGGER

  HANDLE --> PROMPT
  PROMPT --> GPT_API

  API_ROUTER --> NOT_FOUND

  %% Styling classes
  classDef config     fill:#f0f0f0,stroke:#333,stroke-width:1px;
  classDef code       fill:#e0f7fa,stroke:#333,stroke-width:1px;
  classDef assets     fill:#fce4ec,stroke:#333,stroke-width:1px;
  classDef action     fill:#fff9c4,stroke:#333,stroke-width:1px;
  classDef worker     fill:#e8f5e9,stroke:#333,stroke-width:1px;
  classDef logic      fill:#e3f2fd,stroke:#333,stroke-width:1px;
  classDef endpoint   fill:#ffebee,stroke:#333,stroke-width:1px;
  classDef external   fill:#ede7f6,stroke:#333,stroke-width:1px;

STEP 4: Export the diagram

If you log in, you can export as PNG.
If not, you can export it as SVG or take a screenshot.

Note: Technically, this is a flowchart, not an architecture diagram. Mermaid does support architecture diagrams, but they are in beta and don’t look good.

Comments

How to create a Technical Architecture from code with ChatGPT and PlantUML - S Anand 24 May 2025 9:18 am (pingback): […] Earlier, I used Mermaid for technical architectures. But PlantUML seems a better option for cloud architecture diagrams. […]

Automating a podcast from GitHub commits

Sun, 04 May 2025 11:21:20 +0000

Here’s an LLM-generated podcast of what I coded last week. NotebookLM-inspired.

The process proved straightforward.

Get my GitHub commits for the week.
Get the repositories I committed to for more context.
Have an LLM generate a podcast script. I’m using GPT 4.1 Mini but might shift to Gemini 2.5 Flash or DeepSeek V3.
…using a detailed prompt beginning with “You are a podcast script assistant for “Anand’s Weekly Codecast.” This episode is for the week of {WEEK}. …”. Here’s a sample output.
Convert the script to audio. I’m using GPT 4o Mini TTS with customized voices of Ash and Nova.

These now appear on my GitHub repo as a weekly summary.

Beyond technical novelty, it reshaped how I think about documentation.

I write for two audiences: informing my future self what changed and explaining why to an LLM that will narrate it. That’s an interesting behavioral change.
Technical debt is audible. When hearing my week’s work, architectural issues and potential next steps become clear. It creates an accountability mechanism that code reviews often miss.
Ambient documentation. I stop documenting when coding fast. Converting signals (commits) to consumable content creates “ambient documentation” that accumulates with no extra effort. Audio reduces the energy needed to stay up to date.

This could change how we share technical work. Maybe financial analysts “narrate” spreadsheet changes, designers “explain” Figma iterations, or operators “log” settings adjustments - all automated from version control metadata.

Converting activity traces into narratives dramatically lowers cost of knowledge & sharing.

What activity traces do we generate? It’s worth exploring what they could become, and how it’d change behavior if we knew those signals would become stories.

Things I Learned - 16 Feb 2025

Sun, 16 Feb 2025 00:00:00 +0000

This week, I learned:

Connected Papers shows papers similar to each other based on co-citation and bibliographic coupling for ~50,000 papers.
Notes from a fireside chat with Prashanth Chandrasekar, CEO, StackOverflow, and the StackOverflow team
- There’s a signal that software demand is growing in 2024. Many more students took the StackOverflow survey in 2024. So more students (or other professionals) are shifting into / starting to learn software development.
- The AI Index is a good resource for AI trends.
- Experts are better able to use AI for writing code. Less experienced developers are more likely to use AI for code reviews, project planning, etc.
- There’s a 5% decline in favorability for AI tools compared to 2023, maybe due to disappointing results.
- Pilot groups working on AI are 25-30% more productive. They’re the most enthusiastic. For the rest of the company, it drops off to 5-10%
  - #LEARNING Benefit comes from NEW people becoming programmers, not existing ones getting more effective?
- StackOverflow wants to be where the developer is.
  - The programmer workflow was: Google -> StackOverflow -> GitHub.
  - Now it’s changing to ChatGPT / Cursor -> GitHub.
  - StackOverflow has a partnership with OpenAI and working on a plugin. Same with Google’s Duet AI, GitHub Copilot, many others. They’ll link to StackOverflow.
- StackOverflow is driving integration actively through an enterprise Overflow API
- Q: What tech have you seen blaze through the ranks?
  - Prashanth: Abstraction wins. Stuff that abstracts away things well and more wins. This includes Gen AI.
  - Erin Yepis: Rust (from 3% to 12%). AWS has steady growth.
  - Erin Yapis: I have a time series spreadsheet that I’ll publish.
- Q: What technologies are unusually tightly coupled?
  - Prashanth: AWS & Google Cloud are tightly coupled.
- Q: We have an engagement problem. Might be India-specific. What are low-effort high-return mechanisms to increase engagement.
  - Eric Woodring: Rather than a static web page, integrate it using the API. #TODO
  - Ben Marconi: Use LLMs to write post mortems and push to StackOverflow. #TODO
  - Eric Woodring: “Hydrating” the community helps.
    - We take repeat questions on Teams / Slack and seed them using LLMs.
    - We integrate with the API to auto-add Q&A.
    - Transform documentation into Q&A. Potentially UPDATE existing Q&A if it’s wrong.
- Q: What unexpected lessons about developer behavior have you learned while running StackOverflow?
  - Prashanth: We didn’t expect developers moving away from Google. Now it moved to the IDE.
- Q: What are you learning about developer learning behavior?
  - Ben Marconi: Generating LLM-based onboarding documents.
  - Using StackOverflow for Teams to identify who the experts are to contact for specific topics.
- Q: Are you thinking about leveraging Stack Overflow’s knowledge base for personalized or interactive learning experiences? How?
  - Prashanth: Traditionally, people use StackOveflow for productivity, learning, and flexibility (i.e. to ask/answer questions asynchronously without breaking their flow). So yeah, learning is important for us. (Duh!)
- Q: Could Stack Overflow’s interactions help evaluate the accuracy and relevance of LLM-generated code? Or provide potential metrics on quality?
  - Prashanth: LLM accuracy improves by ~30%. Upvotes / downvotes are reinforcement learning (RL) in steroids, so that helps.
- Q: What are your thoughts on reliance on LLMs potentially deskill-ing developers?
  - Prashanth: A real issue for junior developers, not for senior ones.
  - They’ll come across as knowledgeable.
  - Make internal evaluations and interviews more rigorous.
- Anand’s requests for action:
  - Could I get a copy of Erin’s spreadsheet? Vivek Narayanan will follow-up.
  - Could you help me learn more about hydration? Nick Madison will set up a meeting with customer success group.
I switched to fish shell mainly because:
- Autocomplete and tab completion works perfectly, out-of-box.
- Syntax highlighting is beautiful
- Great multi-line editing
To format with VS Code Ruff, you need to point the ruff.interpreter setting to a Python interpreter. You can’t run the ruff server without Python, even though ruff itself doesn’t need Python.
cd checks all paths specified in CDPATH for the directory name and changes to the first match. That’s pretty convenient!
Flipper Zero is now on my list of “To Buy” tools. It has a variety of hardware devices including NFC, RFID, Bluetooth, Infrared, etc. and is great to reverse engineer or hack devices.

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."

From Laptops to Chatbots: Coding at 30,000 ft

Sat, 30 Mar 2024 08:23:58 +0000

Until recently, I could code on flights. This year, I lost that ability. Again.

It’s happened before. In each case, technology has solved the problem for me. Here’s the history.

I need a laptop. Since 2001, I’ve never been without one on a flight.

I need power. Since 2005, I use dark mode and every low power feature available. (I also became good at finding hidden power outlets.)

I need documentation. Since 2007, I use offline documentation. Windows .CHMs gave way to devdocs.io.

I need my notes. Since 2010, all my notes (Markdown files) are synced via Dropbox automatically.

I need CDNs. Since 2014, I’ve replaced CDNs with local node modules. Note to self: Get a local caching proxy instead.

I need GitHub. Since 2023, I have two laptops. So, I git pull manually before flights. Note to self: Find an automated solution.

I need ChatGPT. Since 2024, I stopped coding without ChatGPT. Now I’ve forgotten how to code. Today, I couldn’t figure out the SQL syntax to group by duration == 0 vs duration != 0. Note to self: Get lightweight local code LLMs.

It’s amazing how the coding technology stack has grown. Also amazing how technology fills the gaps in the scaffolding.