codex on S Anand

Things I Learned - 21 Jun 2026

Sun, 21 Jun 2026 00:00:00 +0000

This week, I learned:

It doesn’t always take time to learn or convey things. (Early trust can be built instantly, e.g. vulnerability.) At first, experts don’t know how to make skills explicit. But trainer effort could compress 10X via evals, practice loops, and feedback. Learner elapsed time would compress less.
Everyone has something worth discovering, but not every conversation is worth my time right now. So, meet new people with trust, attention, and good questions. Continue if there’s emotional / intellectual stimulation (surprising, interesting, moving, connecting, energizing, challenging), else exit warmly with respect.
To avoid getting overwhelmed in ultra-interesting conversations, mental closure helps. During the conversation, pause, name, reflect, and close. “Wait, you’re saying X. I should do Y. I’ll reflect/act tonight.” or “Wow, let’s sit with that for 5 seconds. You mean X. I feel Y. I’ll drop.” After the conversation, summarize: “What struck me were X1, X2. I’ll plan Y1, Y2 and drop Z1, Z2.” Then take a short break.
Setting "markdown.editor.updateLinksOnPaste.enabled": false might fix the delay / freezing (infinite spinner) issue when pasting Markdown in VS Code.
The bottleneck to quality of AI output has shifted from model quality to harness quality (and this is not obvious to many people). It is important, therefore, to optimize harness usage rather than prompts usage, i.e. harness engineering over context engineering.
I use ug --smart-case --bool -Q --sort=rtime to interactively search for text in files. It’s like VS Code search-across-files. Here are the shortcuts I find useful:
- Alt-g: Glob (filter files to search in)
- Alt-[ or ]: Decrease or increase context (lines before / after)
- Alt-w: Word match toggle
- Alt-c: Count lines toggle
- Alt-u: Ungroup - show lines once even if multiple matches
Using AI for health seems to have reached a tipping point. Three people have pitched an idea in this space to me in the last three days. One is a managed personal health provider who wants to tie-up with hospitals to gather data to improve AI health advice. Second is an enterpreneur who wants to enable the Indian Govt to use AI to improve public health - given the low proportion of trained doctors in public hospitals. The third is a colleague who is uploading personal health reports, fitness data, DNA data, wearable data, etc. and suggest daily habits such as fitness, nutrition, sleep, medication, etc. to optimize health.
Changing the topic (e.g. asking a question) instead of answering a question is powerful. It lets you decline requests, avoid sensitive topics, ignore boring ones, learn rather than teach, and bring in your agenda - all at one shot. I need to un-practice my 40-year habit of answering questions. (This is selfish. I forgive myself.)
bolt.diy seems like a browser-embeddable coding agent. That is, you can add bolt.diy to your web page and have it build apps. That might be a pretty powerful upgrade to generative UI - where pages build themselves based on the user input.
Codex has a few new features in the last few months.
- Codex can generate images and have voice conversations.
- /goal sets an overall session goal to avoid getting side-tracked.
- /side is like Claude Code’s /btw - for a side task while the main task continues.
- /resume lets you switch to any previous session.
- /keymap debug lets you edit the keymap and inspect what keystrokes the terminal sends.
- @ lets you mention files, directories, skills, and plugins.
- Ctrl+R works, lets you pick a previous prompt.
- Ctrl+O copies the last answer as Markdown.
- Hooks are stable. PreToolUse lets you log every tool, SessionStart lets you inject repo-specific rules.
- MCPs with readOnlyHint can run in parallel.
- codex doctor diagnoses environment issues.
- codex remote-control lets you remotely control Codex, making it a server.
- Codex Python SDK is better and you can have Codex run as a back-end more smoothly.
To change others’ behavior, embody (not preach) it visibly and consistently, make it easy to copy, and ask without forcing. It takes time, though. ChatGPT
Governance is how groups keep promises when things (people, incentives, environment, pressure) change. A simple way to explain what governance is to someone who doesn’t understand why governance matters, and guide on when it does not matter.
Forward Deployed Engineers are the next evolution of data scientists, IMHO. AI can do data science. Data scientists will likely act as the “Human As An Interface” (HaaI) to business, proactively identifying and solving problems - a space business analysts traditionally occupied. Of course, business analysts will likely do the same without needing data scientists to help. But since AI replaces data scientists more than business analysis, I expect that the % of data scientists who become FDEs will be higher than business analysts.
The value of data exported from software is high. For example, your email, social posts, CRM / HRMS / ERP dumps, service tickets, purchases, notes etc. These let you create a personal / organizational digital brain. Hence proprietary solutions will make exports harder and open solutions will emerge.
To live-preview any publicly accessible Excel file, you can embed or link to https://view.officeapps.live.com/op/embed.aspx?src=YOUR-URL
The Codex app can now use the browser much better and faster since last week if you enable “Dev mode” OpenAI. THis uses CDP - which is more efficient than screenshots - and is something Codex CLI has been doing for many months.
In Codex, Claude Code, etc. you can submit a prompt while the agent is working to steer it, i.e. after it completes a turn (e.g. a tool call) it will factor in the prompt. You can also queue it. Neither of these is available on ChatGPT or Claude.ai, though it’s such an important feature. On ChatGPT, submitting another prompt stops the previous run and the agent continues with the new prompt.
By default, git uses ~/.config/git/ignore or %USERPROFILE%\git\ignore as the global .gitignore. You can override that with git config --global core.excludesFile PATH. StackOverflow

Using Codex as my OS

Thu, 23 Apr 2026 21:06:28 -0400

Increasingly, I’m using Codex (or other AI coding agents) as the “operating system” to run programs. That is, rather than directly run programs, I have the coding agent run the program.

Advantage: If the program breaks, or needs a configuration change, the coding agent debugs it and fixes it. I don’t need to do anything.

This is particularly useful for installation. For example:

Install demucs and run it against my music folder.

It’s also useful for brittle scripts. When my WhatsApp scraper broke, I told Codex:

The scraper was working fine but today, it fails. Find out what changed in the WhatsApp Web UI and fix it.

Codex researched and replied:

The current scraper still finds the chat area and message rows, but its row-identity parser is now invalid. On March 28 the code assumed each message node had a packed data-id like:
true_<chat-id>@..._<message-id>
false_<chat-id>@..._<message-id>
Today, in the live WhatsApp tab, the visible message nodes still exist under #main [role="row"], but data-id now looks like a bare message ID:
3A4689CE2A81856D4BB0
ACED689BB5C3115D3DD361F3520F9ECE
...
Because parseDataId() only accepts the old packed format, it rejects every row, so whatsappMessages() returns [], and the bookmarklet shows Copy 0 messages.

WhatsApp appears to have split what used to be one overloaded field into separate concerns:

data-id now behaves like messageId

outgoing direction is likely encoded by DOM class (.message-out)

chat/thread id is no longer bundled into the row data-id

… and went on to share a “Recommended hardening plan for future breakages”.

If coding agents can install, configure, write, run, test, and debug programs, “Agentic Operating Systems” are not nearby. We already have them.

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!

Organizing PDF receipts

Thu, 12 Feb 2026 17:21:14 +0800

One of my goals this year is to “Automate finance + tax”. Today, I took a baby step by organizing my expenses.

This is my current process:

STEP 1: Download PDF receipts (from OpenAI, Anthropic, Google, and other cloud/AI services)
STEP 2: Organize them, so I know which receipt to upload against which expense
STEP 3: Submit on SAP Concur.

All steps are manual as of now. I automated STEP 2: Organize them.

After downloading my PDF receipts, I used this set of prompts on Codex - GPT 5.3 Codex (High)

This folder contains a set of PDF receipts.

Write a well-documented Python script `rename_receipts.py` that renames each .pdf into this format: `2026-02-11 Github $20.00 Card-1004.pdf`. Specifically, `YYYY-MM-DD [Service] [Amount] Card-[Last 4 Digits].pdf`.

- The date should be the PAID date, not the invoice date.
- The service should be a single word vendor name, i.e. Github, OpenAI, Anthropic, Weaviate, Cloudflare, Hetzner, nothing else. You only need to process these formats for now.
- The amount should be the total charged, two decimals, with the currency symbol (e.g. $20.00)
- Include the last 4 digits of the card used for payment.

If the target file exists

- If it is identical to the source file, delete the source file.
- If it is different, print a warning and skip renaming.

Run and test.

---

Fall back to the invoice date only if the date of payment is not available. Skip Card-xxxx if unavailable.

---

How is '2025-12-02 Weaviate $25.00 Card-1004.pdf' different from 'Receipt-2796-1548.pdf'?

---

Let's just check the file sizes, then.

---

Simplify the code further where there are clear opportunities. Retain the documentation and improve readability.

---

Skip processing files that already begin with YYYY-MM-DD.

---

I've added three Google receipts. Update the code to process them the same way and run it. The service name to use is "Google".

---

I've added a new Google PDF. Include that as well, with the service name as Google.

---

I added 2 Hostgator PDFs - h1.pdf and h2.pdf. Incorporate these as well.

---

Any clean-up to the script that might help?

---

Yes, apply these. Also, '2026-01-01 Google $0.80 Card-xxxx.pdf' should be '2026-01-31 Google $0.80 Card-xxxx.pdf' -- we want to go with the statement date.

The result is rename_receipts.py and it works well enough for my receipts over the last 3-4 months.

I’ve partly automated STEP 1 as well. The trickiest bit was converting Google Pay Activity into PDF receipts. This is what it looks like>

To convert the right side into PDF receipts, I asked Claude which gave me this script:

(async function() {
  const element = $0.closest(".b3-section-outer-content");
  const doc = element.ownerDocument;
  const win = doc.defaultView || doc.parentWindow;

  // Collect all CSS
  let css = "";
  for (const sheet of doc.styleSheets) {
    try {
      css += Array.from(sheet.cssRules).map(r => r.cssText).join("\n");
    } catch (e) {
      if (sheet.href) css += `@import url('${sheet.href}');\n`;
    }
  }

  // If in iframe, try to get parent styles too
  if (win !== window) {
    try {
      for (const sheet of window.document.styleSheets) {
        try {
          css += Array.from(sheet.cssRules).map(r => r.cssText).join("\n");
        } catch (e) {
          if (sheet.href) css += `@import url('${sheet.href}');\n`;
        }
      }
    } catch (e) {}
  }

  const html = `<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <style>${css}</style>
  <style>
    body { margin: 0; padding: 20px; }
  </style>
</head>
<body>${element.outerHTML}</body>
</html>`;

  const blob = new Blob([html], { type: "text/html;charset=utf-8" });
  const url = URL.createObjectURL(blob);
  const newWin = window.open(url, "_blank");

  if (newWin) {
    newWin.addEventListener("load", () => {
      setTimeout(() => {
        newWin.print();
      }, 500);
    });
  } else {
    console.error("❌ Popup blocked. Please allow popups for this site.");
  }
})();

Now, I can right-click any receipt in Google Pay Activity, select “Inspect”, then run this script in the console. It opens a new tab with just that receipt, which I print to PDF.

The next step is to automate STEP 3: the Concur submission itself. But that’s for next quarter!

Migrating TDS from Docsify to Hugo

Sat, 07 Feb 2026 12:01:10 +0800

This morning, I migrated my Tools in Data Science course page from Docsify to Hugo using Codex.

Why? Because Docsify was great for a single term. For multiple terms, archives became complex. I still could have made it work, but it felt like time to move towards a static site generator.

I don’t know how Hugo or Go work. I didn’t look at the code. I just gave Codex instructions and it did the rest.

This gives me a bit more confidence that educators can start creating their own course sites without needing coding or platforms. Soon, they might not be stuck to LMSs either - they can build their own.

Here are the prompts I used, along with Codex’s responses, leading to two commits:

Prompt 1

Generate a MIGRATION-PLAN.md for migrating this student course site from docsify to Hugo.

Currenty, this site uses docsify to render Markdown as HTML on the fly.

Create a setup.sh that generates a static version of the site under public/ using Hugo.

Use a popular, elegant, minimal Hugo theme of your choice. We want to retain the sidebar navigation, as well as the archives under 2025-01/, 2025-05/, 2025-09/, and more in the future.

Minimize the custom coding needed to achieve this.

Agent response

I’ll inspect the repository structure to map the current Docsify content layout, then I’ll create MIGRATION-PLAN.md and a setup.sh that builds a Hugo static site into public/ with minimal custom logic and preserved sidebar/archive organization.

I found the Docsify setup and the key files (index.html, root _sidebar.md, plus archive subfolders with their own _sidebar.md/README.md). Next I’ll inspect those files and then draft a migration plan plus an idempotent setup.sh that maps this structure into Hugo with minimal custom templates.

I have enough context to implement this cleanly. I’m now choosing a Hugo docs theme and validating its sidebar configuration model so setup.sh can auto-generate navigation from your existing _sidebar.md files with minimal maintenance for future archive terms.

I validated hugo-book and will use it because it gives a built-in left docs sidebar with minimal configuration. I’ll now implement setup.sh to generate a Hugo workspace from your existing markdown tree and build to public/, then add MIGRATION-PLAN.md describing the migration steps and rationale.

I’m about to add two files: setup.sh (idempotent Hugo build pipeline into public/) and MIGRATION-PLAN.md (phased migration plan, structure mapping, and rollout checks). I’ll keep the approach low-code by relying on Hugo Book’s built-in sidebar behavior and automatic archive folder discovery.

I’ve written both files and will quickly sanity-check them (including a dry run of setup.sh in this environment, which should currently fail early because hugo isn’t installed here).

I found one cleanup point: setup.sh checked for rsync even though it doesn’t use it. I’ll remove that extra dependency and then provide a concise summary of what was added.

Created both requested files:

MIGRATION-PLAN.md
setup.sh

What I implemented:

Chose hugo-book as the theme (popular, minimal, docs-style sidebar).
setup.sh now:
- Creates an isolated Hugo workspace at .hugo-build/site
- Clones hugo-book
- Generates hugo.toml
- Copies tracked markdown into Hugo content/
- Converts every README.md to _index.md (so /, /2025-01/, /2025-05/, /2025-09/ keep clean section URLs)
- Skips Docsify-only _sidebar.md
- Copies all tracked non-markdown files into Hugo static/
- Builds static output into public/

Notes:

I could not run a full build here because hugo is not installed in this environment (Error: missing required command 'hugo').
Once Hugo Extended is installed, run:

./setup.sh

Files:

setup.sh
MIGRATION-PLAN.md

Prompt 2

Use mise x hugo -- hugo and run and test it.

Agent response

I’ll run setup.sh through mise x hugo -- so Hugo is available in PATH for the script, then verify the generated public/ output and key archive routes.

The first run failed because mise couldn’t write under ~/.cache/mise in this sandbox. I’ll rerun using a temporary cache directory and then validate the generated site.

mise x hugo -- hugo is installing the standard Hugo binary (not Extended), so the script’s Extended check fails. I’ll quickly check the available mise variants and use an Extended one to complete the test run.

mise does not expose an “extended” Hugo variant here. I’ll make setup.sh tolerant of standard Hugo (warn instead of hard-fail), then run it with mise x hugo -- and verify whether the build succeeds end-to-end.

The build failed exactly at SCSS compilation, so we do need Hugo Extended for hugo-book. I’m testing mise x hugo@extended -- hugo with temporary mise data/cache dirs to keep everything inside writable paths.

Found the issue: with mise, Extended is a separate tool named hugo-extended (not a variant of hugo). I’ll run using that to complete the test build.

Build now succeeds with Hugo Extended. I’m validating the generated public/ output, including root and archive routes plus sidebar links.

Ran and tested.

Results:

mise x hugo -- hugo version

Output: hugo v0.153.3 ... (non-extended)

mise x hugo -- ./setup.sh

Fails at SCSS compile (TOCSS ... you need the extended version) because hugo-book requires Hugo Extended.

mise x hugo-extended -- hugo version

Output: hugo v0.155.2+extended ...

mise x hugo-extended -- ./setup.sh

Succeeds.
Generated site at public/
Build summary: Pages 289, Static files 103, total ~1.6s.

Validation checks passed:

public/index.html exists
public/2025-01/index.html exists
public/2025-05/index.html exists
public/2025-09/index.html exists
Sidebar contains links for archive terms and pages like marks-dashboard and system-requirements.

I also adjusted setup.sh so non-extended Hugo emits a warning instead of exiting immediately (setup.sh). The actual build still correctly fails later if the active theme needs Extended.

Prompt 3

The sidebar for the home page should only contain the contains of _sidebar.md. The sidebar for 2025-01/, 2025-05/, and 2025-09/ should only contain the contents of the respective folders’ _sidebar.md.

Convert any links to images/ to an absolute link starting with /images/.

Re-run.

Agent response

I’ll update setup.sh to generate section-specific sidebars directly from each _sidebar.md (root and archive folders), override Hugo Book’s menu partial to use those sidebars, rewrite images/ links to /images/, then rebuild and verify the output.

I’m editing setup.sh now to: 1) normalize _sidebar.md into per-section sidebar files, 2) override Hugo Book’s menu partial to render only the correct sidebar by section, and 3) rewrite markdown links from images/ or ../images/ to /images/. Then I’ll rebuild and verify.

Implemented and re-ran with your requirements.

Changes made in setup.sh:

Sidebar behavior:
- Added per-section sidebar generation from source _sidebar.md files:
  - root: _sidebar.md
  - 2025-01/: 2025-01/_sidebar.md
  - 2025-05/: 2025-05/_sidebar.md
  - 2025-09/: 2025-09/_sidebar.md
- Added a Hugo Book partial override at .hugo-build/site/layouts/_partials/docs/menu-filetree.html during build so:
  - home and non-archive pages use only root _sidebar.md
  - pages under /2025-01/, /2025-05/, /2025-09/ use only their own folder sidebar
Link normalization in sidebars:
- Converts .md links to Hugo-style paths (e.g. /foo/)
- Normalizes sidebar-local links like http-requests to /http-requests/
- Removes docsify inline <style> lines from sidebars
Image link rewrite in content:
- Rewrites markdown links from (images/... and (../images/... to (/images/... while copying content into Hugo.

Re-run/test:

mise x hugo -- ./setup.sh still fails because hugo-book needs Extended Hugo (SCSS pipeline).
Successful build command:
- XDG_CACHE_HOME=/tmp MISE_CACHE_DIR=/tmp/mise-cache MISE_DATA_DIR=/tmp/mise-data mise x hugo-extended -- ./setup.sh
Build passed and generated public/ successfully.

Verified output:

Home sidebar only has root _sidebar.md entries (Jan 2026..., Marks Dashboard) in public/index.html.
public/2025-01/index.html sidebar matches 2025-01/_sidebar.md only.
public/2025-05/index.html sidebar matches 2025-05/_sidebar.md only.
public/2025-09/index.html sidebar matches 2025-09/_sidebar.md only.
Image references are rewritten, e.g. src=https://www.s-anand.net/blog/images/portal_notifications.webp in rendered pages.

Prompt 4

The Next and Previous buttons at the bottom should follow the _sidebar.md navigation order in each folder. Add a dark/light mode toggle. Add a GitHub action to deploy this to GitHub pages

Agent response

I’ll extend the build so Hugo uses _sidebar.md order for page-to-page navigation, add an explicit dark/light toggle in the generated site, and create a GitHub Actions workflow that builds with Hugo Extended and deploys public/ to GitHub Pages.

I identified how Hugo Book computes prev/next today; I’m now overriding that partial to read an explicit per-sidebar navigation sequence so buttons follow _sidebar.md order exactly. I’ll also add a small injected toggle that switches BookTheme between light and dark at runtime.

I’m implementing three concrete updates now: generate sidebar-order data from _sidebar.md, override Hugo’s prev-next partial to use that order, and inject a real dark/light toggle using custom SCSS + a small script. After that I’ll add the Pages deployment workflow and run a full rebuild.

I’ve added the workflow and finished the setup.sh changes. Next I’m running a full build with Hugo Extended and validating: 1) prev/next order matches sidebar sequences, and 2) the theme toggle appears and works via injected script/CSS.

The rebuild now passes, and spot checks confirm: footer navigation follows sidebar order (e.g., marks-dashboard -> development-tools -> vscode for the Sep 2025 sequence), plus the dark/light toggle is present and persisted via local storage. I’ll do one final status check and summarize exact file changes.

Implemented all three requests and re-ran successfully.

What changed:

setup.sh
- Added sidebar-order extraction from _sidebar.md into data/sidebar-nav.yaml.
- Added custom prev-next partial override so footer navigation follows _sidebar.md order.
- Kept section-specific sidebar rendering:
  - root pages use root _sidebar.md
  - 2025-01/, 2025-05/, 2025-09/ use their own _sidebar.md
- Added dark/light mode toggle:
  - injects toggle button in sidebar
  - persists preference in localStorage (tds-theme)
  - applies theme via custom SCSS overrides using Hugo Book mixins.
- Kept image link rewrite to absolute /images/....
.github/workflows/deploy-pages.yml
- Added GitHub Pages deployment workflow:
  - triggers on push to main and manual dispatch
  - installs Hugo Extended (peaceiris/actions-hugo@v3)
  - runs ./setup.sh
  - uploads public/
  - deploys via actions/deploy-pages@v4

Run/test performed:

Command used:
- XDG_CACHE_HOME=/tmp MISE_CACHE_DIR=/tmp/mise-cache MISE_DATA_DIR=/tmp/mise-data mise x hugo-extended -- ./setup.sh
Build passed.
Verified:
- Next/Previous follows sidebar order (example: system-requirements -> marks-dashboard -> development-tools -> vscode in Sep sequence).
- Dark/light toggle is present and persists.
- Site generated under public/.

Files:

setup.sh
.github/workflows/deploy-pages.yml

If you want, I can also add a short “Deploy” section to README.md with the exact GitHub Pages settings (Pages source = GitHub Actions).

Prompt 5

Add an appropriate Unicode “icon” for the Dark/Light Mode toggle button .gitignore public/ and any other files you create that should not be committed (if any). Move MIGRATION-PLAN.md to .hugo-build Commit

Agent response

I’ll update the toggle label to include a Unicode icon, update .gitignore for generated artifacts (public/, .hugo-build/), move MIGRATION-PLAN.md into .hugo-build/, then commit only the migration-related files.

I’m applying the requested edits now: iconized toggle text plus ignore rules, then moving MIGRATION-PLAN.md under .hugo-build/. After that I’ll stage only the intended files and commit.

I’ve moved the migration plan and updated the scripts. I’ll run one quick rebuild to ensure the iconized toggle is reflected in output, then commit the exact files (setup.sh, workflow, .gitignore).

I’ve committed the requested changes. I’m doing a quick post-commit check to confirm .gitignore includes generated paths and that MIGRATION-PLAN.md now lives under .hugo-build/.

Done.

Committed as:

1dd73c6 Add Hugo sidebar-ordered nav, theme toggle icon, and Pages deploy workflow

Included in commit:

.github/workflows/deploy-pages.yml
.gitignore
setup.sh

Also completed:

Added Unicode icon treatment for theme toggle (◐, ☀, ☾) in generated site via setup.sh.
Ignored generated artifacts:
- public/
- .hugo-build/
Moved MIGRATION-PLAN.md to:
- .hugo-build/MIGRATION-PLAN.md

Note:

I did not include unrelated working tree changes (e.g. existing README.md modification and other untracked project files) in the commit.

Prompt 6

Don’t implement it, but just tell me: what’s the most elegant, minimal way (directory structure wise) to commit the files setup.sh creates, like hugo.toml, menu-filetree.html, head.html, etc? That way, setup.sh becomes smaller, cleaner, easier to read, and the other files are easier to edit.

Agent response

Most elegant minimal pattern: commit a tiny Hugo scaffold once, and let setup.sh only do content sync + build.

Use this structure in-repo:

hugo/
  hugo.toml
  layouts/
    _partials/
      docs/
        menu-filetree.html
        prev-next.html
        inject/
          head.html
          menu-after.html
  assets/
    _custom.scss
  data/
    sidebar-nav.yaml        # generated by setup.sh (or committed if static)
  sidebars/
    root.md                 # generated by setup.sh (or committed if static)
    2025-01.md
    2025-05.md
    2025-09.md

Then setup.sh just:

Creates .hugo-build/site
Copies hugo/* into it
Clones/uses theme
Generates only dynamic files (data/sidebar-nav.yaml, maybe sidebars/*.md)
Copies content/static
Runs Hugo

If you want even cleaner: keep theme as a Hugo module in hugo.toml and remove theme clone logic too.

Prompt 7

What would the file and directory structure look like if we went the “even cleaner” route?

Agent response

.
├── setup.sh
├── .github/
│   └── workflows/
│       └── deploy-pages.yml
├── hugo/
│   ├── hugo.toml                  # uses Hugo module import for hugo-book
│   ├── assets/
│   │   └── _custom.scss
│   ├── layouts/
│   │   └── _partials/
│   │       └── docs/
│   │           ├── menu-filetree.html
│   │           ├── prev-next.html
│   │           └── inject/
│   │               ├── head.html
│   │               └── menu-after.html
│   ├── archetypes/                # optional (if needed later)
│   └── static/                    # optional fixed assets, favicon overrides, etc.
├── sidebars/                      # source sidebar definitions (copied from docsify or edited directly)
│   ├── root.md
│   ├── 2025-01.md
│   ├── 2025-05.md
│   └── 2025-09.md
├── content-src/                   # optional if you want an explicit input root (or use repo root)
│   └── ... markdown source ...
└── .hugo-build/                   # build scratch (gitignored)
    └── site/
        ├── content/               # generated by setup.sh
        ├── static/                # generated by setup.sh
        └── data/
            └── sidebar-nav.yaml   # generated by setup.sh

Key point: with Hugo Modules, there is no committed themes/ directory and no git clone theme step in setup.sh.

Prompt 8

I want the sidebars to stay where they are. Given this, what will be the only files that get committed?

Agent response

If sidebars remain in-place (_sidebar.md, 2025-01/_sidebar.md, etc.), then only commit the Hugo scaffold and automation files:

setup.sh
.github/workflows/deploy-pages.yml
hugo/hugo.toml
hugo/assets/_custom.scss
hugo/layouts/_partials/docs/menu-filetree.html
hugo/layouts/_partials/docs/prev-next.html
hugo/layouts/_partials/docs/inject/head.html
hugo/layouts/_partials/docs/inject/menu-after.html
.gitignore updates (for public/, .hugo-build/)

Everything else (public/, .hugo-build/, generated nav/sidebar data) stays uncommitted/generated at build time.

Prompt 9

OK, implement that, run and test.

Agent response

I’m going to refactor to the committed Hugo scaffold layout now: move static template/config/style content into hugo/, shrink setup.sh to orchestration only, then run a full build and verify sidebar behavior, prev/next order, and theme toggle.

I confirmed go is not installed locally, so for the Hugo-module route I’ll also wire go into the workflow and test locally with mise x go hugo-extended -- ./setup.sh. I’m now creating committed scaffold files under hugo/ and rewriting setup.sh to just copy scaffold + generate dynamic sidebar data + build.

I’ve finished the refactor to committed scaffold files under hugo/. I’m now running a full build using mise x go hugo-extended -- ./setup.sh and then validating sidebar scoping, prev/next order, and toggle presence in generated HTML.

The first module-based run failed because Hugo Modules needs initialization in the temporary site (go.mod). I’ll add hugo mod init (and module fetch) inside setup.sh, then rerun the build and checks.

Implemented.

What changed:

Refactored to committed Hugo scaffold files under hugo/:
- hugo/hugo.toml (Hugo Module import for github.com/alex-shpak/hugo-book)
- hugo/assets/_custom.scss
- hugo/layouts/_partials/docs/menu-filetree.html
- hugo/layouts/_partials/docs/prev-next.html
- hugo/layouts/_partials/docs/inject/head.html
- hugo/layouts/_partials/docs/inject/menu-after.html
Simplified setup.sh:
- Copies hugo/ scaffold into .hugo-build/site
- Initializes/fetches Hugo modules (hugo mod init, hugo mod get -u)
- Generates normalized sidebars and data/sidebar-nav.yaml from existing _sidebar.md files in-place
- Copies content/static and rewrites images/ links to /images/
- Builds into public/
Updated GitHub Pages workflow:
- .github/workflows/deploy-pages.yml now sets up Go (actions/setup-go@v5) before Hugo Extended.

Run/test:

Executed:
- XDG_CACHE_HOME=/tmp MISE_CACHE_DIR=/tmp/mise-cache MISE_DATA_DIR=/tmp/mise-data GOMODCACHE=/tmp/go-mod-cache GOPATH=/tmp/go-path mise x go hugo-extended -- ./setup.sh
Result:
- Build succeeded (Pages: 289) and generated public/.

Validated behavior after refactor:

Sidebar scoping still correct (home/root sidebar only root entries; 2025-09 uses only its sidebar).
Footer Previous/Next still follows _sidebar.md order.
Dark/light toggle still present with Unicode icons (◐, ☀, ☾) and persisted theme state.

I have not made a new commit in this step.

Prompt 10

Document what each section in setup.sh does and why. A future reader should not be confused. Also document any other sections you created in this session. Then commit.

Agent response

I’ll add clear section-level comments in setup.sh and concise purpose comments at the top of each newly added Hugo override/workflow file so a future maintainer can understand what exists and why, then I’ll commit those documentation-only changes.

I’m now adding maintainership-focused comments to every new/modified scaffold file (setup.sh, Hugo partials/config, SCSS, workflow), then I’ll run a quick build sanity check and commit.

I’ve added section-level documentation across setup.sh and all related scaffold/workflow files. I’ll run one build sanity check, then commit these documentation updates.

Done. I added documentation comments for maintainability across all migration files and committed.

Committed:

fabb96a Document Hugo migration scaffold and setup sections

What I documented:

setup.sh
- Added clear section headers and “why” comments for:
  - path setup
  - dependency checks
  - clean build lifecycle
  - scaffold copy
  - Hugo module init/fetch
  - sidebar normalization
  - sidebar-order extraction for prev/next
  - markdown/static copy rules
  - final Hugo build step
Hugo scaffold files under hugo/
- hugo/hugo.toml: purpose and module/theme notes
- hugo/layouts/_partials/docs/menu-filetree.html: sidebar-selection rationale
- hugo/layouts/_partials/docs/prev-next.html: sidebar-order nav rationale
- hugo/layouts/_partials/docs/inject/head.html: no-flash theme apply note
- hugo/layouts/_partials/docs/inject/menu-after.html: toggle purpose note
- hugo/assets/_custom.scss: theme override and button styling notes
Workflow
- .github/workflows/deploy-pages.yml: top-level comment explaining build/deploy flow via setup.sh.

Validation run:

Rebuilt successfully with:
- mise x go hugo-extended -- ./setup.sh
Build output still succeeds (public/ generated).

Prompt 11

I made a few changes:

I also used dprint to format Markdown files via npm run lint.
In setup.sh I replaced rg with grep since it’s not available in the CI pipeline.
I squash-merged the changes so far.

Now, when I visit /2025-09/ (or any other archive page) it shows me the sidebar correctly. But when I click on the next link, e.g. /system-requirements/ the sidebar becomes that of the root /_sidebar.md. I want to retain the sidebar for each course. So I guess the best way is to copy the content into 2025-09/ and 2025-05/ and 2025-01/ folders respectively. In the future, I will have other courses starting with 2026-_ or 2027-_ etc. It’s safe to say that any folder with a 20YY-MM/ format is a course folder and should have its own sidebar.

Modify minimally and elegantly to handle this required. Run and test. Commit as you go.

Agent response

I understand: for any 20YY-MM/ course, navigation should stay inside that course context (/2025-09/...) so sidebar never falls back to root while moving through next/previous links. I’ll inspect the current setup.sh and generated scaffold, then patch minimally with dynamic course-folder handling and test end-to-end.

I’ve identified a minimal fix: detect all 20YY-MM course folders dynamically, generate course-prefixed sidebar links, and clone shared top-level markdown pages into each course path so navigation stays in-course. I’m applying that now to setup.sh plus the two Hugo partials.

I’ve patched dynamic course detection and course-prefixed navigation. Next I’m running a full build and verifying that /2025-09/ -> next -> /2025-09/system-requirements/ keeps the 2025-09 sidebar (and same for other courses).

Build and behavior checks passed for 2025-09, 2025-05, and 2025-01. I’m committing the minimal fix now (only setup.sh and the two sidebar/nav partials).

Implemented with minimal changes and committed.

Commit:

c54ec05 Keep course sidebar context across next/prev via dynamic course routes

What changed:

setup.sh
- Detects course folders dynamically using 20YY-MM pattern.
- Generates course sidebars for all detected folders (not hardcoded to 2025-*).
- Normalizes course sidebar links to course-scoped URLs (e.g. /2025-09/system-requirements/).
- Generates data/sidebar-nav.yaml dynamically for root + all courses.
- Duplicates shared top-level markdown pages into each course path so course-scoped links resolve.
hugo/layouts/_partials/docs/menu-filetree.html
- Sidebar selection is now dynamic by URL prefix ^/20YY-MM/.
- No hardcoded course list.
hugo/layouts/_partials/docs/prev-next.html
- Prev/Next now uses the dynamic course key from path prefix.
- Keeps navigation inside the current course context.

Run and test:

Built with:
- mise x go hugo-extended -- ./setup.sh
Verified outputs exist:
- public/2025-09/system-requirements/index.html
- public/2025-05/development-tools/index.html
- public/2025-01/development-tools/index.html
Verified behavior:
- /2025-09/ next link points to /2025-09/system-requirements/
- /2025-09/system-requirements/ shows 2025-09 sidebar (not root)
- Same in-course next/prev behavior confirmed for 2025-05 and 2025-01.

Prompt 12

Ensure that:

The current page is highlighted on the sidebar
The next / previous pages show the titles of the pages they link to, not just the title-cased filenames

Again, think about the most minimal, elegant, way to do this.

Agent response

I’ll make two small targeted changes: enrich generated sidebar-nav data with label text from _sidebar.md for accurate next/previous titles, and add a lightweight sidebar-active-link highlighter script so the current page is visibly selected. Then I’ll rebuild and verify.

I’m now updating the nav data format to store both path and human-readable title from _sidebar.md, then switching prev-next to use those titles. I’ll also add a tiny sidebar script for active-link highlighting with minimal CSS.

I’ve applied the minimal patches. I’ll now rebuild and verify two things in generated output: active sidebar class appears on the current page link, and next/previous labels use _sidebar.md titles (e.g. “System Requirements”, “Marks Dashboard”).

Build failed due a Hugo template type issue in prev-next (empty dict fields). I’m applying a safe guard in the template to only read path/title when present, then rerunning the build.

The rebuild now passes; next/previous titles are sourced from sidebar labels. I’ll commit these minimal updates (nav-title mapping + active-link highlighter) and summarize the exact behavior change.

Implemented minimally and committed.

Commit:

44ea7b6 Use sidebar labels for prev/next and highlight active sidebar link

What changed:

setup.sh
- Sidebar nav data now stores both:
  - path
  - title (taken from _sidebar.md link text)
- This preserves human-written titles for navigation labels.
hugo/layouts/_partials/docs/prev-next.html
- Prev/next now reads from { path, title } entries.
- Footer labels use sidebar titles (e.g. System Requirements, Marks Dashboard, 1. Development Tools) instead of derived filename titles.
- Falls back to Hugo page title only if sidebar title is missing.
hugo/layouts/_partials/docs/inject/menu-after.html
- Added a lightweight runtime highlighter:
  - compares current pathname with sidebar link hrefs
  - adds active class and aria-current="page" to the current sidebar link
hugo/assets/_custom.scss
- Added explicit .book-menu-content a.active styling so current page is visibly highlighted.

Run/test:

Rebuilt successfully with:
- mise x go hugo-extended -- ./setup.sh
Verified in generated HTML:
- Prev/next labels now use sidebar titles:
  - /2025-09/system-requirements/ prev = Sep 2025: Tools in Data Science, next = Marks Dashboard
  - /2025-09/marks-dashboard/ prev = System Requirements, next = 1. Development Tools
- Active-link script and style are present in output and will apply on page load.

Prompt 13

Do we really need go and hugo extended? Check if it can run without.

Agent response

I’ll run four quick matrix checks to isolate requirements: hugo only, go+hugo, hugo-extended only, and go+hugo-extended, then report exactly which dependency is truly required and why.

I’m waiting on the final success/failure output for the go + hugo-extended run to complete the matrix conclusively.

Short answer: with the current architecture, yes, both are required.

I ran checks:

hugo only

Command: mise x hugo -- ./setup.sh
Result: fails immediately with Error: missing required command 'go'

hugo-extended only

Command: mise x hugo-extended -- ./setup.sh
Result: same failure: missing required command 'go'

go + hugo (non-extended)

Command: mise x go hugo -- ./setup.sh
Result: fails during build with SCSS error (TOCSS ... need the extended version)

So:

go is required because setup.sh uses Hugo Modules (hugo mod init/get) to fetch hugo-book.
hugo-extended is required because hugo-book compiles SCSS (book.scss).

If you want to drop one:

Drop go: stop using Hugo Modules (vendor/submodule theme in repo).
Drop hugo-extended: use a theme without SCSS compilation (or precompiled CSS-only setup).

Prompt 14

How do I install hugo-extended?

Agent response

Use one of these.

mise (recommended in this repo):

mise use -g hugo-extended@latest
hugo version

mise project-local:

mise use hugo-extended@latest
hugo version

You should see +extended in the version output.

For this project’s build command:

mise x go hugo-extended -- ./setup.sh

Prompt 15

I get this error:

❯ mise x go hugo-extended – ./setup.sh Start building sites … hugo v0.155.2-d8c0dfccf72ab43db2b2bca1483a61c8660021d9+extended linux/amd64 BuildDate=2026-02-02T10:04:51Z VendorInfo=gohugoio

Total in 96 ms ERROR error building site: render: [en v1.0.0 guest] failed to render pages: render of “/” failed: “/home/sanand/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/alex-shpak/hugo-book@v0.0.0-20260108111751-81a841c92d62/layouts/baseof.html:63:5”: execute of template failed: template: list.html:63:5: executing “footer” at <partial “docs/footer” .>: error calling partial: “/home/sanand/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/alex-shpak/hugo-book@v0.0.0-20260108111751-81a841c92d62/layouts/_partials/docs/footer.html:24:3”: execute of template failed: template: _partials/docs/footer.html:24:3: executing “_partials/docs/footer.html” at <partial “docs/prev-next” .>: error calling partial: “/home/sanand/code/tools-in-data-science-public/public/.hugo-build/site/layouts/_partials/docs/prev-next.html:16:16”: execute of template failed: template: _partials/docs/prev-next.html:16:16: executing “_partials/docs/prev-next.html” at <$item.path>: can’t evaluate field path in type interface {}

Agent response

This error is from the prev-next template assuming every nav item is an object with path/title. I’ll patch it to gracefully handle both shapes ("string" and {path,title}), so stale/generated data won’t break builds, then I’ll test and give you the exact recovery commands.

hugo-extended is installed correctly. This error is a template/data mismatch, not an install issue.

Your prev-next.html expects nav items like:

- path: "/2025-09/system-requirements/"
  title: "System Requirements"

But your current setup.sh is still generating plain strings:

- "/2025-09/system-requirements/"

So {{$item.path}} fails.

Fix

Make sure you’re on the latest commit where this was fixed (44ea7b6), or update setup.sh so write_sidebar_nav_yaml() writes both path and title.
Clean generated artifacts:

rm -rf .hugo-build public

Run from repo root (the directory containing .git):

pwd
ls -la .git
mise x go hugo-extended -- ./setup.sh

If you want, I can give you a minimal patch for just write_sidebar_nav_yaml() and prev-next.html to make it robust even if old string-format data appears.

Prompt 16

I’m in the right directory, with the .git. Here’s what I get:

❯ rm -rf .hugo-build public ❯ mise x go hugo-extended – ./setup.sh Start building sites … hugo v0.155.2-d8c0dfccf72ab43db2b2bca1483a61c8660021d9+extended linux/amd64 BuildDate=2026-02-02T10:04:51Z VendorInfo=gohugoio

Total in 2120 ms ERROR error building site: render: [en v1.0.0 guest] failed to render pages: render of “/home/sanand/code/tools-in-data-science-public/.hugo-build/site/content/_index.md” failed: “/home/sanand/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/alex-shpak/hugo-book@v0.0.0-20260108111751-81a841c92d62/layouts/baseof.html:63:5”: execute of template failed: template: list.html:63:5: executing “footer” at <partial “docs/footer” .>: error calling partial: “/home/sanand/.cache/hugo_cache/modules/filecache/modules/pkg/mod/github.com/alex-shpak/hugo-book@v0.0.0-20260108111751-81a841c92d62/layouts/_partials/docs/footer.html:24:3”: execute of template failed: template: _partials/docs/footer.html:24:3: executing “_partials/docs/footer.html” at <partial “docs/prev-next” .>: error calling partial: “/home/sanand/code/tools-in-data-science-public/.hugo-build/site/layouts/_partials/docs/prev-next.html:16:16”: execute of template failed: template: _partials/docs/prev-next.html:16:16: executing “_partials/docs/prev-next.html” at <$item.path>: can’t evaluate field path in type interface {}

Agent response

You’re right, thanks for sharing the exact trace. I’ll make prev-next.html backward-compatible so it works whether nav entries are strings or {path,title} objects, then you can rebuild without depending on one exact setup.sh data format.

I’ve patched the template to accept both data shapes. I’ll quickly run the build once to confirm the error is gone.

Good catch: Hugo evaluates index eagerly, so I rewrote it with explicit if branches to avoid indexing strings. I’ll rerun the build now.

There’s one more edge case: when no prev/next exists, the placeholder map produced a non-string path. I’m patching that guard now (isset checks before reading path/title) so empty edges don’t break rendering.

I’ve reproduced your exact error and fixed it by making prev-next.html robust to both nav data formats. I’m committing this as a small compatibility fix so you can cherry-pick or pull it cleanly.

You’re hitting a real compatibility bug, not an install issue.

Root cause:

Your prev-next template is reading item.path.
Your generated nav data in some runs is still a plain string list.
Hugo errors with: can't evaluate field path in type interface {}.

I fixed this by making prev-next.html support both:

string entries ("/2025-09/system-requirements/")
object entries ({ path, title })

Commit:

b856e7c Make prev/next template compatible with string and object nav entries

I also verified the build succeeds after this fix with:

mise x go hugo-extended -- ./setup.sh

What you should do:

Pull latest hugo branch (or cherry-pick b856e7c).
Re-run:

rm -rf .hugo-build public
mise x go hugo-extended -- ./setup.sh

If you want, I can also give you a one-command patch snippet to apply manually without pulling.

The Jamnagar Chokepoint - Data Story

Thu, 01 Jan 2026 03:14:11 +0000

Vivek published an Indian commodity export/import dataset on 31 Dec 2025.

Codex and Claude increased their rate limits for the holiday season, so I had:

Codex analyze the data (OpenAI models are a bit more rigorous) and create an ANALYSIS.md file.
Claude create a visual story based on the analysis. (Claude narrates and visualizes better).

Here is the data story.

Here are the prompts used.

Analyze

I downloaded export-import.parquet from https://github.com/Vonter/india-export-import which has data sourced from the Indian [Foreign Trade Data Dissemination Portal](https://ftddp.dgciskol.gov.in/dgcis/principalcommditysearch.html)

Each row in the dataset represents a trade entry for a single commodity, country, port, year, month, and type (import or export).

- `Commodity` string: Name of the commodity
- `Country` string: Name of the foreign country
- `Port` string: Name of the port in India
- `Year` int32: Year for the import/export activity
- `Month` int32: Month for the import/export activity
- `Type` category: Type of trade (Import or Export)
- `Quantity` int64: Quantity of the commodity
- `Unit` string: Unit for the quantity
- `INR Value` int64: Value of the commodity in INR
- `USD Value` int64: Value of the commodity in USD

Analyze data like an investigative journalist hunting for stories that make smart readers lean forward and say "wait, really?"

- Understand the Data: Identify dimensions & measures, types, granularity, ranges, completeness, distribution, trends. Map extractable features, derived metrics, and what sophisticated analyses might serve the story (statistical, geospatial, network, NLP, time series, cohort analysis, etc.).
- Define What Matters: List audiences and their key questions. What problems matter? What's actually actionable? What would contradict conventional wisdom or reveal hidden patterns?
- Hunt for Signal: Analyze extreme/unexpected distributions, breaks in patterns, surprising correlations. Look for stories that either confirm something suspected but never proven, or overturn something everyone assumes is true. Connect dots that seem unrelated at first glance.
- Segment & Discover: Cluster/classify/segment to find unusual, extreme, high-variance groups. Where are the hidden populations? What patterns emerge when you slice the data differently?
- Find Leverage Points: Hypothesize small changes yielding big effects. Look for underutilization, phase transitions, tipping points. What actions would move the needle?
- Verify & Stress-Test:
  - **Cross-check externally**: Find evidence from the outside world that supports, refines, or contradicts your findings
  - **Test robustness**: Alternative model specs, thresholds, sub-samples, placebo tests
  - **Check for errors/bias**: Examine provenance, definitions, methodology; control for confounders, base rates, uncertainty (The Data Detective lens)
  - **Check for fallacies**: Correlation vs. causation, selection/survivorship Bias (what is missing?), incentives & Goodhart’s Law (is the metric gamed?), Simpson's paradox (segmentation flips trend), Occam’s Razor (simpler is more likely), inversion (try to disprove) regression to mean (extreme values naturally revert), second-order effects (beyond immediate impact), ...
  - **Consider limitations**: Data coverage, biases, ambiguities, and what cannot be concluded
- Prioritize & Package: Select insights that are:
  - **High-impact** (not incremental) - meaningful effect sizes vs. base rates
  - **Actionable** (not impractical) - specific, implementable
  - **Surprising** (not obvious) - challenges assumptions, reveals hidden patterns
  - **Defensible** (statistically sound) - robust under scrutiny

Save your findings in ANALYSIS.md with supporting datasets and code.
This will be taken up by another coding agent to create reports, data stories, visualizations, dashboards, presentations, articles, blog posts, etc.
Ensure that ANALYSIS.md is documented well enough so that all assets are clear, the approach, intent and implications are understandable.

Visualize

I downloaded export-import.parquet from https://github.com/Vonter/india-export-import which has data sourced from the Indian [Foreign Trade Data Dissemination Portal](https://ftddp.dgciskol.gov.in/dgcis/principalcommditysearch.html)

Each row in the dataset represents a trade entry for a single commodity, country, port, year, month, and type (import or export).

- `Commodity` string: Name of the commodity
- `Country` string: Name of the foreign country
- `Port` string: Name of the port in India
- `Year` int32: Year for the import/export activity
- `Month` int32: Month for the import/export activity
- `Type` category: Type of trade (Import or Export)
- `Quantity` int64: Quantity of the commodity
- `Unit` string: Unit for the quantity
- `INR Value` int64: Value of the commodity in INR
- `USD Value` int64: Value of the commodity in USD

Then I had Codex analyze it. The analysis is in ANALYSIS.md.

Find the most intesting insights from ANALYSIS.md and create a data story with supporting visualizations.

Write as a **Narrative-driven Data Story**. Write like Malcolm Gladwell. Think like a detective who must defend findings under scrutiny.

- **Compelling hook**: Start with a human angle, tension, or mystery that draws readers in
- **Story arc**: Build the narrative through discovery, revealing insights progressively
- **Integrated visualizations**: Beautiful, interactive charts/maps that are revelatory and advance the story (not decorative)
- **Concrete examples**: Make abstract patterns tangible through specific cases
- **Evidence woven in**: Data points, statistics, and supporting details flow naturally within the prose
- **"Wait, really?" moments**: Position surprising findings for maximum impact
- **So what?**: Clear implications and actions embedded in the narrative
- **Honest caveats**: Acknowledge limitations without undermining the story

Visualize like The New York Times Interactives. Ensure that all visualizations interactive and provide revelatory insights as well as some kind of delightful experience.

Follow the typography, color & theme, backgrounds, interaction patterns, and animation principles of The Verge's frontends.

Generate a single page index.html + script.js.

Things I Learned - 02 Nov 2025

Sun, 02 Nov 2025 00:00:00 +0000

This week, I learned:

TVMaze API is an API for TV shows, episodes, cast, crew, etc. Useful for TV-related apps as well as learning APIs.
Awesome Skills is a curated list of prompts and skills for AI coding agents.
⭐ nokode is a API server that has no code: just LLMs responding. Interestingly, it is compliant. Just expensive, slow, forgetful and unreliable compared to code. All four are improving with time, indicating that coding may be transitional.
Notes from Vanya Seth’s keynote at OSAI HYD
- Superpowers of Gen AI to keep in mind when exploring AI coding agent use cases:
  - Translating. Requirements to code, code to code, language to queries, standard to standard.
  - Finding info just-in-time (in context). How does this work? What’s this error? What tools are permitted in my org? Who knows what? E.g. Atlassian Rovo queries across JIRA, Confluence, etc.
  - Brainstorming and ideation. Product ideation. Requirements. Testing gaps. Architecture review. Exploratory / scenario testing.
  - Summarizing and clustering. Change logs, incident management, research data, docs summary.
- Challenges in using AI coding agents:
  1. Adoption imbalance. Only certain roles are amplified by AI. Coding, QA, more than planning, maintenance, AI ops, etc. What’s the impact of this?
    - ⭐ Goldratt’s ToC implies that backlogs need to fill faster. Downstream becomes a bottleneck. Technical debt piles up.
    - ACTION: Use AI across entire value chain, from research to maintenance.
  2. Locality. enhances roles (nodes), not relationships (links). They optimize local work, not global flow. Workflow tools are missing.
    - Coordination overhead. Context Fragmentation. Translation problems.
    - ⭐ Expand productive roles to cover neighboring tasks. Productive developers shift left and build backlogs; shift right to reduce code review, maintenance tasks.
      - E.g. Move maintenance/production activities into development. Security, performance, monitoring, observability, cost, infrastructure.
      - We spend time on IDE, CI/CD, Jira, Confluence, Prod observability tools.
      - A typical Agent Development Platform (ADP) covers evals, guardrails, workflow builder, agent builder, observability, prompt management, AI gateway (LiteLLM), MCP servers, model fine-tuning, model serving, model repository, vector stores
      - We need ADP Agents covering delivery risk, continuous security, prod issues RCA, observability, performance, accessibility, product research, infra optiimzation, test data generation, anomaly detection, release management
      - ACTION: Share ADP photo with Patrick.
  - ACTION: ⭐ Centralize skills (“knowledge packs”) and MCPs and observe which gets used most. Allow people to use more.
  1. Lethal Trifecta. There’s growing demand for higher productivity with AI code assistants. But the lethal trifecta makes them an attack vector. It has access to sensitive information, exfiltrate data, and read and follow unsafe instructions.
    - Can lead to supply chain poisoning attacks.
    - Regulated industries cannot adopt.
  2. Technical debt growth. More productivity leads to poor code quality which will slow down future work.
    - See Software Engineering Excellence 2025
    - AI induced complacency.
    - Sunk-cost fallacy on AI-generated code hurts.
    - ACTION: Evaluate code quality continuously to reduce technical debt. Double-down on good engineering practices.
  3. Compliance.
    - Model residency. Self-hosting is required.
    - Data observability gaps. Data privacy, audit trails, etc. are concerns.
    - Token economics. $20/day happens in Thoughtworks. Token cost is subsidized.
    - Rogue AI usage. Use of dis-allowed tools; shadow IT.
    - ROI justification. Hard to quantify productivity gains.
  4. Adoption.
    - AI Literacy. Tap into organizational knowledge
    - Champions & communities of practice to support cross-pollination.
    - Use-case driven adoption. Teams identify based on AI superpowers.
    - AI playbook. Share what worked, what didn’t work.
AI automation is likely less if a high portion of work
- Has legal liability (e.g. pharmacist/judge vs shop attendant/lawyer)
- Is subjective (e.g. perfumer/auction appraiser vs lab chemist/insurance appraiser)
- Needs rapid contextual decisions (e.g. detective/fireman/ER vs parking enforcer)
- Via ChatGPT, Claude
parse-sse from Sindre Sorhus is a more standards-compliant, more likely-to-be-maintained alternative to my async-sse package.
Which is better: Comment A: 1 upvote, 0 downvotes (100% positive) or Comment B: 99 upvotes, 1 downvote (99% positive)? Use Wilson’s Lower Bound which measures “What % positive am I 95% confident of?” Claude
- Using this, we can measure metrics for tweets, like below. ChatGPT
- Popularity = (5 _ WLB(reposts / views) + 2 _ WLB(likes / views)) * Decay(half-life of 72 h)
- Memorability = (5 _ WLB(bookmarks / views) + 4 _ WLB(replies / views)) * Decay(half-life of 36 hours)
A nice visual “benchmark” of text-to-image and image editing models. Seadream 4, Gemini 2.5 Flash, and Qwen Image Edit lead. This includes examples like straightening te Tower of Pisa - which only Flux.1 and Seadream 4 do well on; or removing only the brown M&Ms - which only Qwen Image Edit manages to.
Arch is a pure LLM router. It supports multiple LLMs, flexible routing and observability but not auth.
From Codex docs
- Add custom prompts in ~/.codex/prompts/xyz.md and launch as /prompts:xyz. Optional: description: and argument-hint: in YAML front-matter. For example, create prompts to refactor, rewrite in a developer’s style, document AGENTS.md, identify re-usable code, etc.
- AGENTS.override.md overrides parent directory AGENTS.md. AGENTS.md appends to parent AGENTS.md. Fallback names are allowed.
- codex exec supports streaming JSON
- codex exec accepts a CODEX_API_KEY= environment variable. codex uses an OPENAI_API_KEY.
- You can configure which environment variables are passed to the shell
- Codex reads 32KB from AGENTS.md by default
Things that I currently follow and don’t follow from Peter Steinberger’s excellent Just Talk To It:
- Prefer Codex > Claude Code.
- Ask for options before executing
- Generate & review specs collaboratively
- You don’t need git worktrees
- Prefer subscriptions over API to reduce cost
- Store docs with code
- Give examples
- Use voice input
- Use Codex Web as a mobile inbox for ideas
- Prefer CLI over agentic platforms
- Prefer CLI tools over MCP
- Avoid ALL-CAPS for Codex. It follows instructions well
- Avoid sub-agents, RAG, etc.
- Iterate UI live. Watch changes
- Use 3-8 agents in parallel on a single repo.
- Make small, atomic commit checkpoints. Commit only what the agent touches
- Add ast-grep as a pre-commit hook to block rule violations.
- Keep custom prompts minimal (commit, automerge, massageprs, review, …). Just “commit” reduces context
- Cancel long tasks and ask what’s happening
- Prefer Medium over High reasoning. It decides level of thinking
- Share screenshots
- Use tmux to run CLIs persistently
- Schedule refactor time (20%). Use jscpd, knip, oxlint, …
- Don’t reset context. Cold start wastes time + tokens
- Write tests in the same context. Yields better tests, reveals bugs.
- Prototype in a separate folder / PR
- Queue continue messages** before stepping away
- Ask it to “Preserve intent and add comments at tricky spots”. Future you needs the WHY
- On hard problems, add “take your time”, “be comprehensive”, “read all related code”, “form hypotheses”, etc.
- Maintain an evolving AGENTS.md with product notes, naming, API patterns, test policy, ast-grep rules, etc. Delete stale guidelines
Fascinating implications from Quantifying Human-AI Synergy ChatGPT
- Models vary in ability to uplift humans. Don’t just use standalone model benchmarks.
- People vary in ability to work with AI. Don’t just measure solo skills. Reward AI collaboration ability (delegation, prompting, verification, revision, …)
- Train models to ask for missing Theory-of-Mind cues: goal, beliefs, constraints, audience, success test
- Train people by asking them to predict what the model will get right/wrong, and validate
- Design UI and models for synergy. UI: Surface/solicit assumptions, intent, uncertainty, constraints. Model: Infer & adapt to evolving user state.

OpenRouter image generation now includes GPT-5 Image Mini. An image costs about 1 cent. Here’s the code:

curl 'https://openrouter.ai/api/v1/chat/completions' \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    model: "openai/gpt-5-image-mini",
    messages: [{ role: "user", content: "Draw a cat" }],
    modalities: ["image"],
    image_config: { "aspect_ratio": "16:9" }
  }' | jq -r '.choices[0].message.images[0].image_url.url' | cut -c23- | base64 -d > cat.png

Vibe-Coding for Interesting Data Stories

Mon, 06 Oct 2025 09:03:35 +0000

Last weekend, I fed Codex my browser history and said “explore.” It found a pattern I call rabbit holes – three ways we browse:

Linear spiral - one page > next page > next. E.g. filing income tax, clicking “next” on the PyCon schedule.
Hub & spoke - hub > open tabs > back to hub. E.g. exploring DHH’s Ubuntu setup, checking Firebase config.
Wide survey - source > many, many pages. E.g. clearing inbox, scanning news.

Then Claude Code built this lovely data story.

My goal? Find challenges in vibe-coding interesting data stories. I found several.

A. I don’t know what I want.

Solution? Ask for multiple options. More options = more ideas. Codex proposed two I hadn’t planned: rabbit holes and search funnels.

B. I don’t know if it’ll turn out well.

Solution? Build them all. Don’t pre-judge. I did not expect rabbit holes to be interesting - a clear prediction error.

C. Reviewing is the bottleneck. It’s slow and painful.

Solution? Make reviews easy.

Ask for review-friendly output. E.g. A table/heatmap comparing options.
Use LLMs to pre-review. E.g. Pick top 3 with reasons.
Review output, not code. E.g. Have it build a working demo, then review.

D. Model / tool strengths vary.

Solution? Align with strengths. For example:

Use GPT-5 for planning. It’s better than GPT-5-Codex or Claude 4.5 Sonnet.
Code UI with Claude 4.5 Sonnet. It’s better than most models.

Check out the prompts & process.

Try this: Pick one messy dataset you have. Ask an LLM for five ways to explore it. Build them all. One will surprise you.

Vibe-Scraping: Write outcomes, not scrapers

Tue, 30 Sep 2025 13:18:20 +0000

There hasn’t been a box-office explosion like Dangal in the history of Bollywood. CPI inflation-adjusted to 2024, it is the only film in the ₹3,000 Cr club.

3 Idiots (2009) is the first member of the ₹1,000 Cr club (2024-inflation-adjusted). The hot streak was 2013-2017: each year, a film crossed that bar: Dhoom 3, PK, Bajrangi Bhaijaan, Dangal, Secret Superstar.

Since then, we never saw such a release except in 2023 (Jawan, Pathan).

But this story isn’t about the box-office drought. It’s about vibe-scraping.

To scrape the 1k Cr club data, here’s what my process would be in:

2008-2015. Requests + BeautifulSoup in Python. Takes ~1 day.
2015-2024. Puppeteer. Still takes ~1 day.
2025-Today. AI writes code. ~2 hours/site. 4x faster.
Today-???. Coding agents scrape directly. ~30 min/site. 16 times faster.

I passed Codex CLI (roughly) this prompt:

Write scrape.py to scrape the highest-grossing films from Wikipedia’s list of Hindi films: 1994 to 2024.
Read pages as required. Save results as CSV.

Here’s what it did.

Read the Wikipedia lists starting 1994
Failed on missing BeautifulSoup dependency. I allowed install.
Discovered that tables below “grossing” or “box office” headings are relevant.
Noticed “Rank” became “No” in the column header since 2016 and adapted.
Fixed all errors and generated a clean CSV.

That’s… incredible!

The code was a by-product. The prompt and evals matter. When sites change, agents can fix the code. Or better agents will rewrite it.

I guess I’ll call this vibe-scraping.

I also asked Claude Code vibe-code a data story. Here are the links:

This afternoon, in front of a client, I spoke with Codex:

Write a scrape.py that searches Dutch fashion merchant websites and lists what delivery carriers they use.

~10 minutes later, we had a table. The client spotted one error that I couldn’t have. Expert review still matters. But what’s redundant is my 20-year scraping experience!

If agents can scrape on the fly, what new questions do we ask?

Tue, 16 Sep 2025 00:00:00 +0000

GPT-5 (Codex) follows instructions exactly as given. Usually a good thing, but sometimes, it this is what happens.

AGENTS.md: ALWAYS WRITE TESTS before coding.

Codex: Let me begin with the tests. (Spends 5 minutes writing tests.)

Anand: Stop! This is a proof of concept. We don’t need tests!

AGENTS.md: Write tests before coding. Drop tests for proof-of-concepts.

Codex: (Proceeds to delete all existing tests.)

Anand: STOP! We need those tests!

AGENTS.md: For new code, or if tests exist, start by writing tests.

Anand: Do this task. … BUT SKIP TESTS! This is a POC!

Codex: The user has explicitly asked to skip tests. But the guidelines require tests for new code. For now, I think I will skip tests.

Anand: (sigh!)

Reminds me of Chaplin’s Feeding Machine.

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.

Things I Learned - 27 Jul 2025

Sun, 27 Jul 2025 00:00:00 +0000

This week, I learned:

Here are some tech community builders in India. ChatGPT
- Atul Chitnis (Bengaluru) – FOSS.IN and Linux Bangalore
- Dr. Nagarjuna G. (Mumbai) – FSF India and ILUG Bombay
- Rushabh Mehta (Mumbai) – FOSS United & ERPNext Community
- Kiran Jonnalagadda & Zainab Bawa (Bengaluru) – HasGeek Tech Conferences
- Kenneth Gonsalves (Nilgiris/Tamil Nadu) – Indian Python Community (deceased)
- Thejesh GN (Bengaluru) – DataMeet Open Data Community
- Varun Aggarwal (Delhi) – ML-India (Machine Learning Forum)
- Prashant Sahu (Pune) – Pune AI Meetup
- Akshay Dashrath (Bengaluru) – BlrDroid Android Group
- Vikrant Singh (Bangalore) – ReactJS
- Sankarshan Mukhopadhyay – Mozilla India and Wikimedia tech outreach
- Neependra Khare (Bengaluru) – Docker/Kubernetes Meetup
- Atul Jha (Bengaluru/Hyderabad) – OpenStack & CNCF Communities
- Aseem Jakhar & Ajit Hatti (Delhi/Pune) – null Open Security Community
- Rohit Srivastwa (Pune) – ClubHack and Hackerspaces
- Anubha Maneshwar (Nagpur) – GirlScript Developer Network
Digital Public Infrastructure initiatives in India scale if there’s a clear use case and centralized orchestration. Prof R Srinivasan
The distance between the end of the thumb and little finger, when fullet stretched, is ~9 inches. Between the thumb and pointer, when at a right angle, is ~6 inches. I checked this today - and it’s right. A useful rule of thumb for measurement - literally. Vasuki, ~1985
GitHub Sponsors Explore shows you which developers code most of your dependencies. You can sponsor them. I sponsored isaacs who maintains node-tap and sindresorhus who maintains several NodeJS packages for $50/month each.
markmap looks like a promising JS-based interactive mindmap from Markdown. More interactive than Mermaid Mindmap.
- mind-elixir is another option that lets you edit mindmaps and serialize in its own format
- jsmind is yet another but docs are in Chinese
- elkjs seems a good option for laying out nodes in an architecture-style flow diagram
⭐ O3 seems a better data scientist than I am. Based on my Google Searches, I have 3 persona: developer, AI-builder, and India/Singapore geo-culturist. A great example of an analysis from O3 that’s better than anything I could have come up with. ChatGPT
⭐ Fast review of AI be a powerful skill and enabler. I built an Image Editing tool with Codex in ~4 hours, with 11 prompts taking 3.5 - 7.5 minutes each. 3 hours human review, 1 hour LLM coding. I’m 3X slower at reviews while AI will keep improving. ChatGPT: Faster LLM review techniques #ai-coding
- Auditize: citations, rationale, output screens, diffs, test results, risks, unknowns
- Auto validate. Evals, tests
- Prioritize. High z-values, big-useful-surprising areas
At the VizChitra Birds of a Feature session, here’s what people said AI enables:
- Complementary skills enable a team of 1. Non-coders can code. Non-domain people get insights from data
- Solves starting trouble. It offers a first draft
- Generation. New ideas (reduces blind spots), scenarios, non-existent people, new data, new persona for surveys
- Hyper-personalization. Parts of YouTube relevant for THIS asset manager. Implication of data for me
- Automated scaling. Generate 1,000 images. Evaluate 1,000 assignments
- Saves time: debugging, research, validation, documentation, copywriting
- New ways of working. Loading event schedules into my calendar
Qwen-Code is a fork of Gemini CLI and uses qwen3-coder – a model that can also be used with Claude Code and Cline. The model is not anywhere near as good as Claude 4 Sonnet. The app is costlier than using Claude Code directly. #ai-coding
The LLM industry seems to have matured quickly. Early adopters who are open to understand the generic capabilities of LLMs through demos are somewhat saturated. The early majority have come in. They aren’t interested in generic capabilities. They’re looking for solutions that solve their specific problem. Soon the late majority will come in asking for existing solutions that have already solved their problem for many others. ChatGPT: Creating demos for majority
Claude for Financial Services is an agentic version of Claude available on AWS & Google marketplaces tuned for financial services analysis. Video
catbox.moe is a file hosting service that you can upload a file to without any API key. It’s an alternative to 0x0.st. Both can be used for images. Catbox retains files indefinitely and openly publishes costs - might last longer. 0x0 deletes files between 1-12 months based on size.
Agents face 3 problems: compounding errors, quadratic costs, and poorly designed tools. Start with small scope & strong reviews while you solve these problems. Betting Against Agents
Leadership and vision will matter more. LLMs iterate fast. They can think for longer. So tasks where people need to work longer independently than LLMs can are what humans will be needed for. That requires understanding the objective. So leadership and specifically vision transfer will become more valuable. You need to be able to tell people what to do well enough that they can work independently for weeks.
Having LLMs go through engineering drawings, floor plans, etc. and understand them, find problems, etc. is an emerging use case. People are using Veo 3 to convert a floor plan into a 3D walk through too.
Digital adoption is slow partly because of a skill gap. “Old-timers” are slow to let go of traditional approaches.
Video recordings are used in manufacturing to evaluate quality (e.g. wafer inspection, assembly inspection, component presence) using AI. An interesting by-product of this data is that they can also measure productivity, task time.
“Common sense is a specialization”. That’s something I said accidentally when seeing that some schools/colleges tend to produce more broad, sensible thinkers (e.g. Naval College @ Goa) while others produce more narrow-thinking specialists (e.g. engineering colleges).
Three groups control the financial economy. To sell sustainability services, you need to have sold to one of them. via Sundeep
1. Banks, who will sell a loan against anything they can insure, and look to insurers for long-term thought leadership.
2. Insurers, who will insure anything they can re-insure, and re-insurers, who look at real-estate trends as a stable long-term asset
3. REITs who own the majority of the world’s real-estate
We could think of a copilot as an (agentic) LLM chat interface for an artifact. E.g. Code pilot (Claude Code. Cursor.). Data analysis copilot (Google Colab, sort-of. ChatGPT). That allows us to imagine tools that will create/edit artifacts. Here are some I’ve encountered as a demand.
- Documents. E.g. Docsearch, GPTs, Microsoft Copilot, Gemini
- Slides. E.g. Microsoft Copilot, Gemini
- Sheets. E.g. Microsoft Copilot, Gemini
- Code. E.g. Cursor, Claude Code
- Database. Create DB schema, ER diagrams, synthetic data, ingestion scripts, etc.
- Data (analysis). E.g. Datachat, Google Colab, Marimo
- Posters. E.g. Postgen
- Shell. E.g. Warp
- Topic modeling. E.g. classify
- Surveys. E.g. Personagen
- APIs. E.g. apiagent
- Drug regulatory submissions.
- Contracts (risk).
- Manufacturing SOPs.
- Curriculum.
- Data quality.
- Support tickets.
- Dashboards.
- IaaC / DevOps.
- Video campaigns.
- Resumes.
- Patents.
CLI optimization for LLMs will likely emerge. More CLIs (and wrappers / hooks in the shell) will improve output and error contexts for LLMs, e.g. printing current directory, caching slow outputs, suggesting alternate commands, etc. Ref
Frequent commits with linting & building seems like a good AI coding strategy, especially for Claude Code. Ref #ai-coding

To keep Claude Code in line on my project, I’ve relied heavily on linters, build scripts, formatters, and git commit hooks. It’s pretty easy to get Claude Code to commit often by including it in your CLAUDE.md, but it often likes to ignore other commands like “make sure the build doesn’t fail” and “fix any failing tests”. All my projects have a .git/hooks/pre-commit script that enforces project standards. The hook works really well to keep things in line.
Google Apps Scripts are actually a web apps platform in JavaScript more than a macros equivalent. Ref
⭐ DuckDB supports joins based on embedding similarity and even hybrid similarity! Ref
Human persuasion techniques like Cialdini’s work well with LLMs Ethan Mollick
gitwatch is a clean way of auto-committing & pushing files into GitHub. It effectively converts GitHub into a Dropbox-like service.
Adding ?udm=14 to Google Search URLs removes AI mode and other clutter. Ref
⭐ Never embed LLM‑generated summaries without a disclaimer, source links, and flag‑as‑wrong feedback button. Build a fast appeal/edit pipeline before release. via Death By AI

Sun, 22 Jun 2025 09:52:29 +0000

I use Codex and Jules to code while I walk. I’ve merged several PRs without careful review. This added technical debt.

This weekend, I spent four hours fixing the AI generated tests and code.

What mistakes did it make?

Inconsistency. It flips between execCommand("copy") and clipboard.writeText(). It wavers on timeouts (50 ms vs 100 ms). It doesn’t always run/fix test cases.

Missed edge cases. I switched <div> to <form>. My earlier code didn’t have a type="button", so clicks reloaded the page. It missed that. It also left scripts as plain <script> instead of <script type="module"> which was required.

Limited experimentation. My failed with a HTTP 404 because the common/ directory wasn’t served. I added console.logs to find this. Also, happy-dom won’t handle multiple exports instead of a single export { … }. I wrote code to verify this. Coding agents didn’t run such experiments.

What can we do about it?

Detailed coding rules. E.g. always run test cases and fix until they pass. Only use ESM. Always import from CDN via JSDelivr. That sort of thing.

100% test coverage. Ideally 100% of code and all usage scenarios.

Log everything. My tests got a HTTP 404 because I was not serving the common/ directory. LLMs couldn’t figure this out because it was not logged. Logging everything helps humans and LLMs debug.

Wait. LLMs and coding agents keep improving. A few months down the line, they’ll run more experiments themselves.

Was AI coding worth the effort? Here, yes. The tools worked. Codex saved me 90% effort. My code quality obsession reduced savings to ~70%. Still huge.