High-fidelity image copying unlocks practical workflows like OCR cleanup, map restoration, and animation in-betweening, not just prettier images.

Summary: Nano Banana Pro is much better than recent models at copying images without errors. That lets us do a few useful things, like: Pre-process images for OCR, improving text recognition by cleaning up artifacts while preserving text shapes exactly. Convert textbook raster diagrams into clean vector-like images that vectorizers can process easily. Create in-betweens for cartoon animations Copy torn, stained 1950s survey maps into pristine, high-contrast replicas with boundary lines preserved pixel-perfectly. Redraw sewage map blueprints or refinery blueprints into clean schematics, separating the "pipes" from the "background noise". ... and more! GPT Image 1.5 has a good reputation for drawing exactly what you tell it to. But right now, nothing beats Gemini 3 Pro Image Preview (Nano Banana Pro) on copying images exactly. To check this, Nitin asked a bunch of models to: ... and passed it different kinds of images. Here's their structural similarity index (SSIM): Image Type gemini-3-pro-image-preview gemini-2.5-flash-image gpt-image-1.5 chatgpt-image-latest gpt-image-1 gpt-image-1-mini Document 89.4% 33.6% 14.0% 10.0% 7.9% 8.3% Diagram 97.9% 32.2% 32.4% 24.4% 26.9% 31.6% Stereogram 98.5% 37.8% 41.1% 34.1% 36.1% 39.6% Scatterplot 89.1% 85.9% 46.3% 41.9% 36.0% 38.5% Surreal painting 99.7% 66.7% 77.2% 76.6% 72.2% 51.4% Tuvalu map 96.2% 99.9% 72.4% 61.8% 64.5% 65.4% Cartoon 99.8% 81.3% 72.3% 71.9% 72.4% 72.3% Human photo 99.3% 76.1% 82.9% 82.2% 74.0% 71.8% Human portrait 99.9% 84.7% 93.4% 89.8% 89.5% 77.0% Landscape 99.8% 95.7% 93.1% 92.4% 90.3% 92.0% Overall Average 97.0% 69.4% 62.5% 58.5% 57.0% 54.8% For example, take this portrait: Gemini 3 Pro is nearly pixel perfect. (Red areas show differences. You can see that most areas are barely different.) Whereas GPT Image 1.5 makes more changes: The nose is smaller.\ The mouth is wider.\ The lips are thinner.\ The eyes are smaller.\ The moustache is smaller.\ The goatee is neater.\ The face is narrower.\ The skin is yellower.\ ... and so on. But even the best models aren't perfect when copying diagrams and documents. The text is slightly displaced. Background writing is removed. Gemini 3 Pro actually sharpens the text. But even here, interestingly, almost every letter is copied correctly - the differences are small. What does this mean? Clearly, Gemini 3 Pro Image Preview outperforms the others by a huge margin. Winner in 10 categories, with a 97% average. The runner up (Gemini 2.5 Flash Image) wins barely nudges it out on the Tuvalu map, and has a 69% average. Also, the models are clearly better at natural images (human photo, portrait, landscape) than with symbolic images (cartoon, diagram, scatterplot, document). Among the OpenAI models, GPT Image 1.5 is far better than the others, but lags far behind Gemini 3 Pro. The gap is larger for symbolic images - so definitely prefer the Gemini models to edit diagrams, documents, charts etc. Also, Gemini 3 Pro Image Preview seems quite different from Gemini 2.5 Flash (20% correlation)- almost a different model, whereas GPT Image 1.5 seems fairly similar to GPT Image 1 and GPT Image 1 Mini (97% correlation) - like incremental improvements to the same model. You can try out your own images at or run the code yourself.

Gemini copies images almost perfectly


The main value of Gemini's business offering is not better intelligence but enterprise defaults around privacy, admin control, and legal protection.

I got an email from Google Cloud on my work account "excited to introduce you to Gemini Enterprise". Once I signed up, it said, "you have 30 days to try Gemini Enterprise – Business edition at no cost." After that, it costs US $21/user/month, which I can subscribe to here. The main differences from Gemini Pro (consumer accounts) seem to be: 1. Data Privacy. Google won't read or use your data to train. (In Pro, you need to turn it off explicitly. Here, it's the default.) 2. Admin Controls. Admins can turn off connectors, manage users, retention policies, etc. 3. Copyright Indemnification. If AI infringes copyright and you get sued, Google will find the case. But if you're using Gemini via your Google Workspace account (i.e. your work account already has Pro subscription), then it makes no difference - it's all the same. So I have no clue why Google's mailed me to buy the same product I already have.

Gemini Enterprise Business


A simple bookmarklet can make Gemini conversations portable by exporting entire chats as Markdown.

Gemini lets you copy individual responses as Markdown, but not an entire conversation. That's useful if you want to save the chat for later, pass it to another LLM, or publish it. So I built a bookmarklet that scrapes the entire conversation as Markdown and copies it to the clipboard. SETUP: Drag the bookmarklet to your bookmarks bar. USAGE: On a Gemini chat page, click the bookmarklet. It copies the chat as Markdown. Here's a sample output: NOTE: When I vibe coded this at first, I got an error that made me think Gemini's Content-Security-Policy prevents executing javascript: URLs. But on testing, the CSP actually looks like: This specifically allows unsafe-inline scripts, which is what bookmarklets are. So it works fine.

Gemini Scraper


Gemini can turn pasted or attached content into rich sketchnotes with a very simple prompt, making visual summarization much more accessible than before.

I use this prompt to generate sketchnotes on Gemini: Draw this as a visually rich, intricately detailed, colorful, and funny, sketchnote. Below that, I paste (or attach) whatever content I want it to draw. I also turn on "Create Images" and switch the model to "Pro" (for better thinking.) Here are some examples of how to use it. Summarize articles. Pick email, report, news, or website. Here's a sketchnote for this article: How to use AI for research. I used the prompt above and pasted the article text. Sketchnote Summarize presentations. Pick any proposal, status update, project report, or meeting agenda. Here's a sketchnote we emailed SNHU as pre-read before the meeting. I used the same prompt and attached the presentation. They loved the sketchnote! Sketchnote Summarize books. Pick any textbook, non-fiction, fiction, or anthology. This sketchnote summarizes Morgan House's book Same as Ever Sketchnote Summarize talks. Pick from YouTube, TED, podcast, or even meeting transcripts. This sketchnote summarizes a talk by Rob Schrauwen of Elsevier. He really liked the sketchnote too! Sketchnote Explain a workflow. Pick from any slide, architecture diagram, process document, or paper sketches. This sketchnote documents a proposal submission workflow Sketchnote NOTE: For complex documents or long transcripts, I add this line so that Gemini thinks first and creates a more structured sketchnote: Think about the most important points, structure it logically so that the sketchnote is easy to follow, then draw it. With sketchnotes, you unlock am interesting capability. It catches attention - it's colorful and engaging. It signals simplicity - so people are more likely to read it. It sets you apart - it's rare when people try something different. It's personal - you can create a distinct version tailored to each audience - in minutes. It takes just one prompt in front of any content. Try it out: Draw this as a visually rich, intricately detailed, colorful, and funny, sketchnote.

Gemini Sketchnotes


I’m bringing back email subscriptions for my blog via a Google Group. I developed a Python script using Claude, markdown2, and premailer to format and send my posts as HTML emails through the Gmail API.

TL;DR: Join this Google Group to get my blog updates via email. My blog is over 25 years old. At first, people had to visit it to read it. Then I added an RSS feeds. Then email subscriptions. Then via social media, cross-posting on Twitter, now LinkedIn. The RSS feed remains. But I feel it's time to bring back email subscriptions. It's the oldest of the technologies, the most robust, and the one I believe will last the longest. My blog might last another 25 years. I'm willing to bet email will outlast RSS and certainly the social media platforms. So, I've created a Google Group: s-anand@googlegroups.com where I will post new blog entries. You can join the group to get email updates whenever I post something new. For now, I will post updates manually. After a few weeks of testing, I'll automate the process. PS: I use a htmlemail.py script to send blog posts as HTML emails via the GMail API. It was vibe-coded by Claude and taught me a few things: The frontmatter package is a clean way to parse YAML frontmatter from markdown files. LLMs aren't familiar enough with the markdown2 package, which is the new standard for processing Markdown. They prefer markdown instead. premailer is a well-maintained package to inline CSS for HTML emails. pygments is the de facto standard to generate CSS for syntax highlighting code blocks.

Get this blog via email on Google Groups


Google's AI ecosystem is broad and uneven, so a practical tool map matters more than a comprehensive catalog.

Google has released a huge number of AI tools. Not all are useful, but some are quite powerful. Here's a list of the tools ChatGPT could find. 🟢 = I find it good. 🟡 = Not too impressive. 🔴 = Avoid. Assistants, research, and knowledge work 🟢 Gemini is Google's main AI assistant app. Use it as a meeting-prep copilot: paste the agenda + last email thread, ask for "3 likely objections + crisp rebuttals + 5 questions that sound like I did my homework." 🟢 Gemini Deep Research is Gemini's agentic research mode that browses many sources (optionally your Gmail/Drive/Chat) and produces multi-page reports. Use it to build a client brief with citations (market, competitors, risks), then reuse it for outreach or a deck outline. 🟢 Gemini Canvas turns ideas (and Deep Research reports) into shareable artifacts like web pages, quizzes, and simple apps. Use it to convert a research report into an interactive explainer page your team can share internally. 🟢 Gemini Agent is an experimental "do multi-step tasks for me" feature that can use connected apps (Gmail/Calendar/Drive/Keep/Tasks, plus Maps/YouTube). Use it to plan a week of customer check-ins: "find stalled deals, draft follow-ups, propose times, and create calendar holds-show me before sending." 🟢 NotebookLM is a source-grounded research notebook: it answers from your uploaded sources and can generate Audio Overviews. Use it to turn a messy folder of PDFs into a decision memo + an "AI podcast" you can listen to while walking. 🟡 Pinpoint (Journalist Studio) helps explore huge collections of docs/audio/images with entity extraction and search. Use it for internal investigations / audit trails: upload contracts + emails, then trace every mention of a vendor and its linked people/locations. 🟢 Google AI Mode exposes experimental Search experiences (including AI Mode where available). Use it for rapid competitive scans: run the same query set weekly and track what changed in the AI-generated summaries vs links. Project Mariner is a Google Labs "agentic" prototype aimed at taking actions on your behalf in a supervised way. Use it to prototype a real workflow (e.g., "collect pricing from 20 vendor pages into a table") before you invest in automating it properly. Workspace and "AI inside Google apps" 🟢 Google Workspace with Gemini brings Gemini into Gmail/Docs/Sheets/Drive, etc. Use it to turn a weekly leadership email into: (1) action items per owner, (2) a draft reply, and (3) a one-slide summary for your staff meeting. Google Vids is Workspace's AI-assisted video creation tool. Use it to convert a project update doc into a 2-3 minute narrated update video for stakeholders who don't read long emails. Gemini for Education packages Gemini for teaching/learning contexts. Use it to generate differentiated practice: same concept, three difficulty levels + a rubric + common misconceptions. Build: developer + agent platforms 🟢 Google AI Studio is the fast path to prototyping with Gemini models and tools. Use it to build a "contract red-flagger": upload a contract, extract clauses into structured JSON, and generate a risk report you can paste into your workflow. Firebase Studio is a browser-based "full-stack AI workspace" with agents, unifying Project IDX into Firebase. Use it to ship a real internal tool (auth + UI + backend) without local setup, then deploy with Firebase/Cloud Run. 🟢 Jules is an autonomous coding agent that connects to your GitHub repo and works through larger tasks on its own. E.g. give it “upgrade dependencies, fix the failing tests, and open a PR with a clear changelog,” then review it like a teammate’s PR instead of doing the grind yourself. Jules Tools (CLI) is a command-line interface for running and monitoring Jules from your terminal or CI. E.g. pipe a TODO list into “one task per session,” auto-run nightly maintenance (lint/format/test fixes), and have it open PRs you can batch-review in the morning Jules API lets you programmatically trigger Jules from other systems. E.g. when a build fails, your pipeline can call the API with logs + stack trace, have Jules propose a fix + tests, and post a PR link back into Slack/Linear for human approval Project IDX > Firebase Studio is the transition site if you used IDX. Use it to keep your existing workspaces but move to the newer Studio flows (agents + Gemini assistance). Genkit is an open-source framework for building AI-powered apps (workflows, tool use, structured output) across providers. Use it to productionize an agentic workflow (RAG + tools + eval) with a local debugging UI before deployment. Stax is Google’s evaluation platform for LLM apps (prompts, models, and end-to-end behaviors), built to replace “vibe testing” with repeatable scoring. E.g. codify your product’s rubric (tone, factuality, refusal correctness, latency), run it against every prompt/model change, and block releases when key metrics regress SynthID is DeepMind’s watermarking approach for identifying AI-generated/altered content. E.g. in an org that publishes lots of content, watermark what your tools generate and use detection as part of provenance checks before external release SynthID Text is the developer-facing tooling/docs for watermarking and detecting LLM-generated text. E.g. watermark outbound “AI-assisted” customer emails and automatically route them for review if they’re about regulated topics Responsible Generative AI Toolkit is Google’s “safeguards” hub: watermarking, safety classifiers, and guidance to reduce abuse and failure modes. E.g. wrap your app with layered defenses (input filtering + output moderation + policy tests) so one jailbreak prompt doesn’t become a security incident Vertex AI Agent Builder is Google Cloud's platform to build, deploy, and govern enterprise agents grounded in enterprise data. Use it to build a customer-support agent that can read policy docs, query BigQuery, and write safe responses with guardrails. Gemini Code Assist is Gemini in your IDE (and beyond) with chat, completions, and agentic help. Use it for large refactors: ask it to migrate a module, generate tests, and propose PR-ready diffs with explanations. PAIR Tools is Google’s hub of practical tools for understanding/debugging ML behavior (especially interpretability and fairness). E.g. before launch, run “slice analysis + counterfactual edits + feature sensitivity” to find where the model breaks on real user subgroups LIT (Learning Interpretability Tool) is an interactive UI for probing models on text/image/tabular data. E.g. debug prompt brittleness by comparing outputs across controlled perturbations (tense, style, sensitive attributes) and visualizing salience/attribution to see what the model is actually using What-If Tool is a minimal-coding tool to probe model predictions and fairness. E.g. manually edit a single example into multiple “what-if” counterfactuals and see which feature flips the decision, then turn that into a targeted data collection plan Facets helps you explore and visualize datasets to catch skew, outliers, and leakage early. E.g. audit a training set for missingness and subgroup imbalance, then fix data before you waste time “tuning your way out” of a data problem 🟡 Gemini CLI brings Gemini into the terminal with file ops, shell commands, and search grounding. Use it as a repo-native "ops copilot": "scan logs, find the regression, propose the patch, run tests, and summarize." 🟡 Antigravity (DeepMind) is positioned as an agentic development environment. Use it when you want multiple agents running tasks in parallel (debugging, refactoring, writing tests) while you supervise. Gemini for Google Cloud is Gemini embedded across many Google Cloud products. Use it for cloud incident triage: summarize logs, hypothesize root cause, and generate the Terraform/IaC fix. Create: media, design, marketing, and "labs" tools Google Labs is the hub for many experiments (Mixboard, Opal, CC, Learn Your Way, Doppl, etc.). Use it as your "what's new" page-many tools show up here before they become mainstream. 🟡 Opal builds, edits, and shares AI mini-apps from natural language (with a workflow editor). Use it to create a repeatable analyst tool (e.g., "take a company name > pull recent news > summarize risks > draft outreach"). 🟡 Mixboard is an AI concepting canvas/board for exploring and refining ideas. Use it to run a structured ideation sprint: generate 20 variants, cluster them, then turn the top 3 into crisp one-pagers. Pomelli is a Labs marketing/brand tool that can infer brand identity and generate on-brand campaign assets. Use it to produce a month of consistent social posts from your website + a few product photos. 🟡 Stitch turns prompts/sketches into UI designs and code. Use it to go from a rough wireframe to React/Tailwind starter code you can hand to an engineer the same day. 🟡 Flow is a Labs tool aimed at AI video/story production workflows (built around Google's gen-media stack). Use it to create a pitch sizzle reel quickly: consistent characters + scenes + a simple timeline. Whisk is a Labs image tool focused on controllable remixing (subject/scene/style style workflows). Use it for fast, art-directable moodboards when text prompting is too loose. ImageFX is Google Labs' image-generation playground. Use it to iterate brand-safe visual directions quickly (e.g., generate 30 "hero image" variants, pick 3, then refine). VideoFX is the Labs surface for generative video (Veo-powered). Use it to prototype short looping video backgrounds for product pages or events. MusicFX is the Labs music generation tool. Use it to generate royalty-free stems (intro/outro/ambient) for podcasts or product videos. Doppl is a Labs try-on style experiment/app. Use it to sanity-check creative wardrobe ideas before you buy, or to mock up "virtual merch" looks for a campaign. 🟢 Gemini Storybook creates illustrated stories. Use it to generate custom reading material for a specific learner's interests (and adjust reading level/style). TextFX is a Labs-style writing creativity tool (wordplay, transformations, constraints). Use it to generate 10 distinct "hooks" for the same idea before you write the real piece. GenType is a Labs experiment for AI-generated alphabets/type. Use it to create a distinctive event identity (custom letterforms) without hiring a type designer for a one-off. Science, security, and "serious AI" AlphaFold Server provides AlphaFold structure prediction as a web service. Use it to test protein/ligand interaction hypotheses before spending lab time or compute on deeper simulations. Google Threat Intelligence uses Gemini to help analyze threats and triage signals. Use it to turn a noisy alert stream into a prioritized, explainable threat narrative your SOC can act on. Models 🟡 Gemma is DeepMind’s family of lightweight open models built from the same tech lineage as Gemini. E.g. run a small, controlled model inside your VPC for narrow tasks (classification, extraction, safety filtering) when sending data to hosted LLMs is undesirable 🟡 Model Garden is Vertex AI’s catalog to discover, test, customize, and deploy models from Google and partners. E.g. shortlist 3 candidate models, run the same eval set, then deploy the winner behind one standardized platform with enterprise controls Vertex AI Studio is the Google Cloud console surface for prototyping and testing genAI (prompts, model customization) in a governed environment. E.g. keep “prompt versions + test sets + pass/fail criteria” together so experiments become auditable artifacts, not scattered chats Model Explorer helps you visually inspect model graphs so you can debug conversion/quantization and performance issues. E.g. compare two quantization strategies and pinpoint exactly which ops caused a latency spike or accuracy drop before you deploy Google AI Edge is the umbrella for building on-device AI (mobile/web) with ready-to-use APIs across vision, audio, text, and genAI. E.g. ship an offline, privacy-preserving feature (document classification or on-device summarization) so latency and data exposure don’t depend on the network Google AI Edge Portal benchmarks LiteRT models across many real devices so you don’t guess performance from one phone. E.g. test the same model on a spread of target devices and pick the smallest model/config that consistently hits your FPS/latency target TensorFlow Playground is an interactive sandbox for understanding neural networks. E.g. use it to teach or debug intuitions—show how regularization, feature interactions, or class imbalance changes decision boundaries in minutes Teachable Machine lets anyone train simple image/sound/pose models in the browser and export them. E.g. prototype an accessibility feature (custom gesture or sound trigger) fast, then export the model to a small web demo your stakeholders can try Directories ("where to discover the rest") Google DeepMind Products & Models (Gemini, Veo, Astra, Genie, etc.)-best "canonical list" of what exists. Google Labs Experiments directory-browse by category (develop/create/learn) to catch smaller experiments you didn't know to search for. Experiments with Google is a gallery of interactive demos (many AI) that’s great for prompt/data literacy and workshop “aha” moments. E.g. curate 5 experiments as a hands-on “AI intuition lab” for your team so they learn failure modes by playing, not by reading docs

Google AI Tools List


A tiny Google Meet bookmarklet can stream live captions into local Markdown, making meeting transcripts agent-readable without waiting for platform exports.

I'm a man of simple needs. All I want is: when I'm on Google Meet, I turn on captions. I wanted to click a bookmarklet and save those captions into a local Markdown file. (So that an AI agent can guide me from it.) Hence, Google Meet Captions. The code is in gmeetcaptions/. Drag the button to your bookmarks bar. Join a Meet. Turn on captions. Click it. You get a tiny panel with two buttons: Copy and Start Recording. The bookmarklet writes this kind of Markdown: That's it. No server. No extension. No login. No API. Just a bookmarklet page, a script, and local browser APIs. BUT: Google Meet captions are live and unstable. A sentence may appear as: Then a second later become: Then become: If I simply append every change, the transcript becomes garbage. So the bookmarklet keeps updating the active speaker turn until it becomes stable. The implementation uses a MutationObserver plus a one-second polling fallback. After four unchanged polls, it treats the turn as final. The tests are in gmeetcaptions.test.js, using an anonymized fixture at fixtures/captions-anonymized.html. BUT #2: Google Meet's DOM is not a public API. Class names like .nMcdL, .NWpY1d, and .ygicle can vanish overnight. So the scraper first tries semantic and structural selectors: [role="region"][aria-label="Captions"] for the captions region img[data-iml] and googleusercontent.com avatars to identify caption items the first as the speaker the last non-image as the caption text Only then does it fall back to obfuscated class names. That selector strategy is documented in the README. Boring, but also the difference between "worked once" and "might work tomorrow." The weirdest was Chrome writing to a .md.crswap file while recording. The file appears unfinished until I click Stop Recording. Then Chrome finalizes it. This is good, actually. It means the browser is safely streaming to a local file via the File System Access API. But it also means: stop the recorder before trusting the file! I captured these bugs and prompts in prompts.md, because future-me will forget. Future-agent, too. Why bother? Because transcripts are not the output. They are raw material. Once a meeting is Markdown, I can ask agents to extract decisions, questions, follow-ups, contradictions, reusable prompts, and blog ideas. I can diff it. Search it. Commit it. Feed it to another workflow. Meetings now become the "context" in context engineering!

Google Meet captions as a local transcript recorder


AI agents can automate idea generation and editorial production pipelines well enough to create publishable media content with minimal manual intervention.

Last Friday, 20 Mar 2026, this "Hack of the Day" was published by The Times of India. My agents generated it entirely automatically. Here's how that happened. On 12 Feb 2026, I met Rohit Saran, Managing Editor at The Times of India. "Our biggest challenge is the starting challenge. What story to do?" he said. "We waste a lot of time and we starve stories because of this." What if AI could help with that? We talked for nearly two hours - and left asking: "Should we do just a daily visual newspaper?" Rohit connected Saurabh, Saikat, and Sajeev, so we could explore what's possible. FIND PROMISING CANDIDATES. The Times of India already had recurring formats they wanted to drive with AI. Statoistics (data-driven visual explainers of statistics and trends) was one. Hack of the Day (small tech tips for non-tech-savvy readers) was another. We weren't beginning from scratch. There was rich material and a realization that recurring newsroom formats are ideal for AI because they are structured, frequent, and feedback-rich. Hack of the Day stood out: small, recurring, text-only, needing little research, with a clear purpose — useful tech tips for everyday readers. Saikat defined 3 concrete goals for this: 1. Generate about 90 new hacks to extend the feature for around three more months. 2. Generate those in the existing format. 3. Explore alternative visual formats for future replacement or redesign. STUDY THE ARTIFACT. So, on 6 Mar 2026, Saikat sent me 10 samples of Hack of the Day to understand the format, layout, variety, etc. By 10 Mar 2026, I had a few prototypes ready. I asked ChatGPT a series of questions: [](https://chatgpt.com/share/69c6231b-b89c-83a1-bf0b-41b03d8ccc3e) 1. Analyze these 10 "Hack of the Day" images carried in The Times of India. If I had to ask an intern (or an AI agent) to create several such, then what prompt will give me this kind of content in exactly this format? 2. List all past hacks from https://timesofindia.indiatimes.com/technology/hack-of-day - it has 2 pages, read from both 3. Find and list 10 high impact non obvious widely useful hacks similar to these 4. Write these hacks in the format of the cards below. Mimic the structure, style, and verbosity of the cards. (Schema attached) 5. Nice! Continue the search extensively and give me 10 more. Make sure these are ULTRA useful to a LARGE number of people and yet many people are probably not aware of these hacks. ... to create a cards.json. Then I asked Claude Code to "Create a template.html that can be combined (e.g. via mustache) with a JSON that, when run, produces the EXACT visual output as the cards in \.avif." Saikat reviewed these and noted that some had already been done by TOI, but some looked new and usable. So the first batch served as a proof of possibility. DO MORE OF WHAT AI DOES WELL To get the output fast and to make iterations easier, I did a few things that are easy for AI and not natural for humans: Generate code, not images. The TOI team had experimented with image generation. That didn't work well - and I know that. I proposed generating HTML/SVG instead. It does that well. It's editable by humans and AI. That makes the workflow practical. Use JSON, not English. I used ChatGPT to research and generate structured JSON, then Claude to render it visually. Each tool did what it does best. Specifically, I had ChatGPT generate structured JSON that can be easily read and programmatically processed by coding agents. Generate many variations. Generation is cheap. I had ChatGPT generate dozens of hacks in one go. I had Claude generate design variations like Classic Blue, Broadsheet Heritage, Saffron Signal, etc. Publish a gallery. Creating a gallery of generated outputs is a simple enhancement that allows for easier review, comparison, and selection. The Gallery made reviews and feedback much easier. These make iterations faster, richer, more reliable and reviewable. ITERATE FEEDBACK FAST During the session on 10 Mar, I spoke with ChatGPT and told it (verbally) what Saikat said: Look, all of this is nice, but some of these have already been covered by the Times of India's previous hack of the days. Also, I get a feeling that it's getting a little repetitive. Let's go a little global, doesn't have to be only about Indian government sites. Let's talk about things that people use on a practical, day-to-day basis and see what is really useful and not always obvious to them, even though there is a widespread adoption of some of these. It doesn't have to be technological hacks either. It could be social hacks, educational hacks, cultural hacks. The point is that it should be from some primary source. Now, keeping this in mind, give me about a dozen of these and give it in the JSON format that you've done so far. Feedback is the critical loop. The system improved not because the model changed, but because the editorial feedback got sharper. I explicitly asked for voice-note feedback on WhatsApp to speed up the review cycles. Just one line explaining what's rejected and why. By 17 Mar 2026, we had 64 hacks, of which 32 were rejected for these reasons: 15: "Published earlier" 1: "Duplicate of a similar one" 15: "Hacks must be platform agnostic" (not Android / iPhone specific) 1: "Not a tech hack" (e.g. health) RETAIN EXISTING VISUAL FORMATS People are used to seeing things in a certain way. That inertia has value (brand recognition, reader familiarity, workflow compatibility, etc.) That was reflected in the granular feedback Sajeev shared about the design (which I translated directly into prompts): The fonts are much smaller The steps are supposed to look like folders, overlapping / stacked. Right now, they look like rounded cards with a gap between them. Hack of the day is not horizontally / vertically centered. The QR code formatting is off. The name in the email ID should be in bold, and the domain in regular font. The number in the steps must be larger, and in a different font - look carefully. The text in the steps must be closer to the number - look carefully. Vertically center the step elements. Replace fonts with the closest Google Fonts. The hacks are typically taller. Increase the size of the cards. The color contrast (blue on blue) makes a lot of content barely visible. Review the foreground-background color contrast across elements and ensure contrast while preserving aesthetics. STEPS: is too small and too close to the "What to do" section We still haven't nailed it perfectly. This is a long tail. The big win is getting it to the point where manual edits are minor. ALIGN WITH EXISTING WORKFLOWS TOI needed outputs designers could adjust in their workflow. The team uses InDesign / Illustrator, so we needed to: Align with tools. I prompted: "I could not load the generated SVGs on Gnome nor on VS Code's image viewer. But they render on Chrome. Get them to work on these as well. Keep in mind that they'll finally be opened by Adobe Illustrator and similar tools - so tool compatibility is important. Update SVG templates accordingly and test if you can." Align with fonts. I prompted: "Modify the hackoftheday/ HTML and SVG to use the Poynter Agate One font from assets/\.otf. Use the bold condensed / condensed versions." Work around tool quirks. I prompted: "Modify the SVG rendering to native SVG elements: text and tspan (not foreignObject, div), rect, clipPath, defs > style, named fonts, styles scoped via CSS classes on SVG elements, static pre-positioned elements. No JavaScript, div, @import, QR code library, etc. Use robust libraries for conversion if required." PUSH FOR PRODUCTION New workflows take time to stick. 6 Mar to 20 Mar (two weeks) is probably record time. The actual generation took a few hours. Reviews took a few days. Most of the time was just the gap between meetings, where ideas sink in. The impetus came from the meetings where I kept asking: "What's stopping us from publishing?" and then fixing that. On 20 Mar 2026, the first AI-assisted Hack of the Day was published. More followed. Show Gemini your screen or camera for live help My agents are an integral part of a newsroom. This is so cool!

Hack of the Day on Times of India


Improving container setup quality depends less on memorizing all best practices and more on having good tests, readable output, and agents that can iterate on both.

I run AI coding agents inside a Docker container for safety. The setup is dev.dockerfile: builds the image dev.sh: launches the container with the right mounts and env vars dev.test.sh: verifies everything works. I wrote them semi-manually and it had bugs. I had GitHub Copilot + GPT-5.4 High update tests and actually run the commands to verify the setup. Here's what I learned from the process. 1. Make it easier to review. The first run took long. I pressed Ctrl + C , told Copilot to "add colored output, timing, and a live status line". Then I re-ran. Instead of a bunch of ERROR: lines, I now got a color-coded output with timing + a live status line showing what's running. PASS 2.495s markitdown --help FAIL 0.003s playwright --version note /home/sanand/code/scripts/dev.test.sh: line 148: playwright: command not found FAIL 0.003s copilot version note /home/sanand/code/scripts/dev.test.sh: line 148: copilot: command not found 2. Run in the target environment. Tests reported that fd and node were missing, though they were obviously in the image. Why? The test script was running on my laptop, not in the container. It was checking the host, not the container. I didn't realize that. Copilot added a check to see if we're already inside a container: 3. Check for conflicting commands. fd and node were still missing. Why? dev.sh was mounting my host mise and bin directories, overshadowing the image It doesn't matter what's installed in the container - only the host binaries are visible. Copilot removed the first line, and copied mise into /.local/overrides/ to override the /.local/bin PATH. 4. Use the right packages. The default ImageMagick binary at https://imagemagick.org/archive/binaries/magick is an AppImage. It doesn't work in containers. So it hat to switch to apt-get install -y imagemagick instead. 5. Use the right paths. npm install -g wscat playwright ... ran but to add them to the PATH, you need to mise reshum node. Copilot added that. These are good practices, but since agents can fix them, they're less important to learn. Vibe-coding good tests enabled Copilot to fix them.\ Making output easy to read enabled me to steer Copilot. That's what I'd recommend if you're trying to optimize setup / deployments.

Hardening my Dev Container Setup


A tiny intervention like heating a cookie can transform the eating experience enough to feel like a genuine discovery.

I ordered a Caramel Cashew Cookie - Soft & Chewy at the Chennai airport, an hour before my flight. I've had cookies before, but not heated. The person at the counter put it in the microwave for 30 seconds before handing it to me. It was the best discovery I made in Jan 2026! It is crumbly. It is chewy. It melts. It soaks. It bends when you pick it up. It's warm. It's sweet. It's nutty. It's gooey. Oh, I could go on. It's heavenly. Since then, I've had a few cookies - all heated. They always taste better hot - especially if they're almost melting. (The taste of the more buttery ones improves more.) There's a reason for it. 80% of taste is actually smell. When heated, cookies vaporize carrying the smell of vanilla, caramel, butter, etc from the mouth to the nose. TRPM5, a taste "valve", opens when hot. That's why melted ice cream tastes sweeter. So do hot cookies. Heat melts fat, which coats the mouth evenly. That carries the flavors to every corner of the mouth. Some other foods that taste better hot are: Brie or Camembert cheese Peaches, plums, and nectarines Dark chocolate (like in a sizzling brownie sundae or a choco lava cake) Banana bread (or any dense loaf / cake) Pecan pie Cinnamon rolls Leftover pizza I haven't tried them all, but I repeat: hot cookies are my best discovery this month! Source: Gemini

Hot cookies


I map how AI bottlenecks shift across coding, agents, and enterprise data. By examining transitions from tool-calling to reliability and context windows to evaluation, I highlight why yesterday’s impossible tasks are today’s standard features.

I wrote about my changing AI opinions. At least some of this is because the industry is moving so fast that the bottlenecks keep shifting. Here are four examples of how we AI couldn't do something (the bottleneck), but that became possible, and the bottleneck shifted - changing the way we work. It's good to keep this in mind when thinking about AI. Coding: 1. "It can't write useful code. We can't get real help." But in Sep 2022: GitHub finds Copilot developers are 55% faster. 2. "It writes code but doesn't know our codebase. We can't let it touch real projects." But in Feb 2024: Gemini 1.5 Pro has 1M-token context 30K LOC". Cursor indexes code. 3. "It understands the repo but can't ship a fix on its own. We can't hand it a whole issue." But in Mar 2024: Devin solves 14% of SWE-bench - up from 2%.. Verified SWE-Bench is now 70%+. 4. "It ships fixes, but we can't review them fast enough or trust they're stable." Oct 2024: DORA 2024 finds AI hurt both throughput and stability. Now: Sep 2025: DORA 2025 finds is positive but stability stayed negative. Now: Jul 2025: METR's RCT finds experienced devs 19% slower. Agents 1. "It does one step. We can't chain actions." But Jun 2023: OpenAI function calling lets models invoke tools and return structured calls. 2. "Every integration is bespoke. We can't connect it to all our systems." But Nov 2024: Anthropic open-sources MCP, standardizing tool and data access. 3. "It can act and connect, but over a long task its errors compound. We can't trust a 20-step run." Now: Mar 2025: METR finds autonomous task horizon doubling every 7 months. Reliability is a challenge. But Claude Mythos, with a 16 hour reliable execution, might fix this. Enterprise knowledge work 1. "It only knows the public internet. We can't use it on our own documents." But Sep 2023: Morgan Stanley's assistant uses 100K internal documents. 2. "It reads our documents but can't fit enough of them. We can't ask across the whole corpus." But May 2023: Claude's 100K-token context and Feb 2024: Gemini 1.5's 1M tokens reduce chunking needs. 3. "It runs on our data, but we can't trust it without a way to measure when it's silently wrong." Now: the Morgan Stanley deployment relies on an eval framework - evals are the bottleneck. Document processing 1. "It needs thousands of labeled samples. We can't stand up new doc types quickly." But Sep 2023: Google Document AI extracts with limited-to-no ML training. 2. "It learns fast but reads only text. We can't handle scans, charts, and tables." But Sep 2023: GPT-4V vision model and May 2024: GPT-4o native multimodal solved this. 3. "It sees the page but can't understand long, layout-heavy documents. We can't trust it on real multi-page files." Now: NeurIPS 2024: on MMLongBench-Doc, GPT-4o scored under 50 on multi-page chart/table documents. But Gemini 3.5 Flash, GPT 5.5, Claude 4.8 Opus, etc. have excellent vision and need to be tested.

How AI bottlenecks shift


AI can reshape teaching most effectively when it changes the structure of learning and assessment, not just the speed of content creation.

I've been using AI in my Tools in Data Science course for over two years - to teach AI, and using AI to teach. I told GitHub Copilot (prompt) to go through my transcripts, blog posts, code, and things I learned since 2024 to list my every experiment in AI education, rating it on importance and novelty. Here is the full list of my experiments. 1\. Teach using exams and prompts, not content ⭐ Use exams to teach. The typical student is busy. They want grades, not learning. They'll write the exams, but not read the content. So, I moved the course material into the questions. If they can answer the question, great. Skip the content. Use AI to generate the content. I used to write content. Then I linked to the best content online -- it's better than mine. Now, AI drafts comics, interactive explainers, and simulators. My job is to pick good topics and generate in good formats. Give them prompts directly. Skip the content! I generated them with prompts anyway. Give students the prompts directly. They can use better AI models, revise the prompts, and learn how to learn with AI. ⭐ Add an "Ask AI" button. Make it easy for students to use ChatGPT. Stop pretending that real-world problem solving is closed-book and solo. ⭐ Make test cases teach, not just grade. Automate the testing (with code or AI). Good test cases show students the kind of mistake they may - teaching them, not just grading them. That's great for teachers to analyze, too. Test first, then teach from the mistakes. Let them solve problems first. Then teach them, focusing on what failed. AI does the work; humans handle what AI can't. This lets us teach really useful skills based on real mistakes. 2\. Make cheating pointless through design, not detection ⭐ Allow copying, collaboration, and hacking. In real work, nobody gets bonus points for working alone or re-inventing the wheel. Collaboration, using available resources well, verifying inputs, disclosed shortcuts -- all are rewarded. Reward originality without punishing collaboration. Blanket anti-copying rules assume that all similarity is bad. A more AI-native approach is to allow learning from others openly, but give extra credit for genuine variation, initiative, and novel improvement. ⭐ Give each student a unique variant. If everyone sees the same problem with the same visible answer path, answer-sharing becomes the dominant strategy. Deterministic but unique variants shift the game from leaking answers to actually solving the problem. Make process logs part of the evidence. When outputs can be copied or AI-generated, the trace becomes more valuable than the final artifact. Logs, verification notes, session recordings, and agent traces show whether the student can actually orchestrate the work. Use repo-grounded vivas for authenticity. If you really want to know whether a student owns their project, ask them questions drawn from their own repo and make them change something live. That is much harder to fake than polished submitted output. Use structural similarity, not string matching. Strip docstrings, tokenize, MinHash. Students who rename variables are still caught; students who genuinely collaborated produce detectable clusters rather than suspicious pairs. 3\. Test skills that matter in an AI world ⭐ Teach what AI still cannot do well. Syntax and routine execution are declining in value. Judgment, debugging, orchestration, validation, integration, and taste are rising. The curriculum should move upward, not cling to the parts AI is already eating. Use hard, messy problems to build real resilience. Some questions should be intentionally tricky, partly wrong, hidden in the UI, or out of syllabus. The students who find and solve them anyway are demonstrating exactly the adaptability that real work demands. Smooth progression alone doesn't build that. Test live, hands-on AI skills. Don't just lecture about embeddings, vision, structured outputs, or hallucinations. Put students in live API-driven tasks where they have to use these things under time pressure and genuine uncertainty. Grade students on designing AI workflows. In many real settings, the important skill is not "give the answer" but "design the chain of steps that gets to the answer reliably." That includes tools, prompts, datasets, quality checks, fallbacks, and output formats. Use game-like tasks to teach agentic work. Mazes, escape rooms, and API games force state tracking, exploration strategy, and backtracking — exactly the behaviors agentic systems require. They're not gimmicks; they're the syllabus. Test prompt attacks and defenses. Security and adversarial literacy should not be abstract topics. Make students jailbreak, defend, manipulate, and harden model behavior. That turns "prompt security" from a lecture topic into a measurable skill. 4\. Make assessment more like real work Grade richer work, not just one-line answers. Real work is often multimodal: images, stories, APIs, analyses, and dashboards. If assessment automation cannot handle those, it will keep pushing education toward fake neatness. Grade the spec, not the code. When AI writes the code, the real artifact is the machine-readable brief: goal, constraints, done-when, counter-examples, eval suite. That is often where the actual thinking lives anyway. Count real open-source contributions as coursework. A merged PR to a public repo is harder, messier, and more educational than most sealed academic assignments. It teaches scoping, etiquette, usefulness, and real external standards. Let students build virtual TAs from real course material. The project is educational, and the output becomes infrastructure for the next cohort. Good assignments should create assets, not just submissions. Reward originality structurally, not just rhetorically. Most courses praise creativity but grade only correctness. Use embeddings to measure cohort-level similarity and explicitly reward meaningfully distinct outputs. Originality becomes real, not decorative. 5\. Use AI to build the course, not just teach inside it Let AI write, test, and fix draft questions. The interesting move is not just "AI drafts items." It is "AI drafts, runs, breaks, revises, and improves them before any student sees them." That dramatically changes how fast a course can evolve. Use coding agents to test the exam before students do. If an agent solves a question instantly, you should ask what the question is actually measuring. Agents become both QA tools and mirrors for curricular relevance. Use AI-generated comics to explain why the question exists. Students often resist tasks they do not understand. A comic can smuggle in the pedagogical point with very low friction and high memorability. Use interactive explainers for unfamiliar concepts. AI can generate not just text answers but visual, animated, intuitive explanations. That makes concept onboarding faster for both students and new faculty. Keep teacher adoption in familiar formats. A good innovation that slots into slides, handouts, OCR flows, and short feedback loops will beat a brilliant system nobody can actually use next semester. 6\. Build the infrastructure for AI in education ⭐ Break rubrics into binary sub-criteria; reason before judging. Open-ended project grading becomes more auditable when you decompose it into binary yes/no criteria and ask the model to explain its reasoning before delivering a verdict. High or suspicious scores get re-evaluated with stronger guardrails. Give every student shared, budgeted AI access. If AI access depends on personal subscriptions, the institution is quietly grading wealth, not skill. Shared governed access makes AI a course capability, not a private advantage. Let AI handle routine support; keep humans for judgment. AI handles repetitive, searchable, first-pass questions. Humans handle ambiguity, reassurance, escalation, and final accountability. Neither alone is the right model at scale. Turn recurring answers into canonical Q&A cards. Once the same question appears three times, it should stop living in somebody's head or an old thread. Convert it into a canonical artifact that both humans and bots can cite consistently. Govern with green/amber/red review levels. Not every decision needs the same scrutiny. Auto-ship the low-risk, spot-check the medium-risk, always human-review the high-stakes. This is how you scale without losing trust. Roll out in shadow mode first. High-stakes academic workflows should not be launched with fingers crossed. Run the AI system quietly in parallel with human judgment and learn before turning it loose. Turn policy into executable checks. A policy that cannot be operationalized at scale is mostly theater. If you can translate rules and rubrics into machine-checkable form, governance becomes consistent rather than person-dependent. Make the course publicly inspectable. Openness raises the bar. It invites scrutiny, reuse, criticism, and improvement, and it turns the course into a visible institutional experiment rather than a sealed classroom. Use reasoning models only for the borderline cases. Cheap screening first, expensive verification for the high-stakes or suspicious. Increasing reasoning effort on even a small model can flip an evaluator from sloppy to reliable — the cost curve makes this the natural operating model. 7\. Analyze and research learning exhaust Track which AI tools students actually use. Once AI use is instrumented, you stop guessing. You can see which models students choose, when they ask for help, and what behavior actually correlates with success. Redesign exams from behavior data, not intuition. Model choice, timing, retry patterns, and deadline behavior all reveal how students really work. That should feed back into question design, support strategy, and pacing. Analyze broken code before it compiles. Novices often fail at syntax long before you reach the real misconception. Structural parsing of broken code lets you give feedback on thought process instead of just rejecting the submission. Use code traces to surface hidden misconceptions. Timestamped traces reveal overfitting, thrashing, structural confusion, and missing invariants — patterns that polished final submissions hide entirely. Turn replay galleries into faculty-readable stories. Raw logs do not change policy. Narrated replays and plain-language error-pattern reports do. The point is to make evidence legible to decision-makers, not just analysts. Break problem-solving into coachable steps. "Weak student" is too vague to be useful. Better to ask: did they fail at reading the givens, choosing a strategy, surviving a multi-select trap, or knowing when to cut losses? Each is a trainable failure mode. Study bias in peer review itself. If peer assessment matters, reviewer quality matters too. You can detect generous, timid, extreme, and calibrated graders from the data, then moderate or train accordingly. Treat learning analytics as a reusable research programme, not a one-off dashboard. The infrastructure for tracking misconceptions, prerequisite transfer, and course-to-course movement can be built once and reused across cohorts. That turns isolated AI experiments into institute-level knowledge and publishable educational research. 8\. Upgrade the human role Make judgment and taste explicit learning goals. AI makes average output cheap. The premium moves to selecting what is worth doing, recognizing quality, and knowing what to reject. That is a teachable skill, not a vague aspiration. Teach directional feedback as a skill. You do not always need to micromanage AI with detailed corrections. The higher-order skill is to say "more concrete," "less jargon," "optimize for faculty adoption," or "make this defensible." That is learnable and more effective than micromanaging. Teach faculty to manage agents, not just chat with them. Institutional AI does not scale on prompting alone. People need to learn specs, budgets, kill switches, and escalation rules — orchestration literacy, not just chatbot familiarity. Use AI as a personalized coach. The model is not just an answer engine. It can become a research guide, curiosity amplifier, and next-step recommender tailored to the individual learner's gaps and goals. Let non-coders build interactive learning tools. AI lowers the cost of making timelines, maps, biographies, and interactive explainers. That opens AI-native pedagogy far beyond computer science into humanities and social sciences. Teach students to run many AI attempts in parallel. One of the biggest AI-native workflow shifts is from single-path effort to portfolio thinking — run several attempts, compare them, and converge faster. That is a teachable habit, not an obvious default.

How I use AI to teach


Local MCP turns my laptop into an AI-readable context repository, letting Claude and ChatGPT combine chat memory, local files, shell tools, email, calendar, transcripts, and code into useful work.

I'd love for Claude or ChatGPT to answer questions like: What meetings am I not setting up that I really should be? or: Based on my activities since 9 May 2026, what should I blog about? or: Who in my professional life most deserves an unreasonable gesture? From data. My files, emails, calendar, contacts, transcripts, blogs, notes, code, browsing history, logs, random Markdown files I forgot I wrote. Hence, a Local MCP. My Local MCP server exposes one tool: bash. That's it. No vector database. No UI. No custom connectors. No "AI knowledge platform." Just: run shell commands on my machine. I run this locally, expose it online (which is slightly scary), and give Claude and ChatGPT this prompt fragment: In one shot, this gives EVERYTHING I have to the agents. A common use is meeting prep. You are a brilliant, brutally honest Chief of Staff. You have full access via Local MCP bash tool to calendar, emails, and past transcripts. Produce a briefing card for each substantive external meeting today. It checks the calendar via gws. It searches my transcripts. My notes. My AI advice. Then gives me a briefing card with everything I need. I can't do this by uploading files manually. The context is not one file: it's scattered all over. A human assistant could do this. But agents are faster, cheaper, and I trust them more. Another common use is relationship intelligence. What meetings am I not setting up that I really should be? Claude scans transcripts, contacts, emails, and recent activity to find people I should speak. This is where Local MCP is different from a file upload. In a file upload, I can ask "Where is X?". Here, I'm asking "What am I missing?" and the answer depends on recency, relationship history, frequency, how conversations felt, unresolved actions, and so much more. A third use is mining my own work. I used Local MCP to ask what I should blog about. It scanned all my content and found themes I haven't really thought about, like: Google Meet captions - a code commit I recently made. I wrote about it. Agents are the new software - a theme I've been talking a lot about. I wrote about it. Local MCPs - that's this post ... and half a dozen topics I should be writing about soon. A fourth use is business research. I have transcripts from sales calls and client conversations. I don't attend all of them. But Local MCP can. I can ask: Which client needs have we heard repeatedly but not converted into demos? or: Which solutions have we pitched to one client that another client has explicitly asked for? This is beyond a CRM search. A HubSpot search finds what people typed in. This finds what people actually said. Then an email search finds if they acted on it. Calendar search finds what we spent time on. Across these, I find opportunities that no single system has. BUT: this is not safe by default. A bash MCP server can delete my files, run commands, read my browser sessions, send emails gws, and all sorts of risky things. So I monitor the commands like a hawk, and give it fairly controlled access, and only when I'm actually running one of these use-cases. I tried OAuth but setting up Auth0, dynamic client registration, callback URLs, scopes, ChatGPT connector errors, ... I gave up. For now, supervised local usage gives me most of the value. BUT #2: Claude and ChatGPT use Local MCP differently. Claude uses it beautifully. Smooth. No mistakes. References memory. ChatGPT is more restrictive. No chat memory accessed, nor saved. Keeps asking for permissions. So I use ChatGPT less for Local MCP-heavy tasks. But ChatGPT is rigorous. When I want structured analysis, exhaustive lists, or better verification discipline, it is useful. Local MCP is powerful because it lets AI use all systems I have access to: local files - across Dropbox, Google Drive, my notes, blog posts, transcripts, slides, ... code - not just reading, but running, rewriting, and generatig email, calendar, contacts browser history shell tools - which can be used to access even more system Local MCP invites Claude / ChatGPT as a real assistant into my laptop. And into my 2,700-line TODO archive. You probably shouldn't expose a bash tool to an AI. But note the direction I'm going with this: If your work and transactions are agent-readable, your past work compounds. If they are trapped in apps, screenshots, and memory, your AI has amnesia.

How I use Local MCP


I used LLMs to audit IMF GDP forecasts, revealing a systematic optimistic bias for future growth. You can use AI to fact-check institutional datasets, identify specific country-level errors, and generate interactive visualizations to expose hidden patterns.

The IMF forecasts GDP growth every year. Their forecasts for the current year are slightly low. Their forecasts for the next year are slightly high. After that, it remains high. Some forecasts, like China, Singapore, UAE, Equatorial Guinea are consistently low. Other forecasts, like Japan, Congo, Mexico, Pakistan are consistently high. The interesting meta-pattern is how this sort of past-forecast analysis can be done for any topic. This emerged from an Ethan Mollick post and then I asked: Me: Ethan Mollick had GPT-5.5 Pro update his grad school paper. Cool! What can I do like this? Claude: Analyze your past work - like your blog posts. 1. Fact-check it 2. Find wrong sources 3. Critique it 4. Find contradictions 5. Find buried ledes / unbuilt sequels 6. Find what aged badly. What's the pattern? Me: Um, what about others' work? Claude: Sure! 1. Check IMF GDP forecast accuracy 2. Check target market size forecasts 3. Check company / asset price forecasts 4. Find which books are based on studies no longer true 5. Find sources of popular stats that are wrong 6. Find what numbers people quietly revised Me: Where can I find IMF GDP forecasts? ChatGPT: On the IMF Data WEO site Me: Check IMF GDP forecast accuracy. ChatGPT: The IMF has a modest optimistic bias for future-year GDP-growth forecasts, but not for same-year nowcasts. Me: Translate that to English. ChatGPT: For the current year, IMF typically underestimates. Next year onwards, they typically overestimate. Me: Why? How? ChatGPT: IMF has systematic biases. Advanced economies are easier to forecast and slightly less biased Some countries (China, UAE, ...) are largely under-forecasted. Others (DR Congo, Haiti, ...) are consistently over-forecasted. They underpredicts extremes in both directions. When their forecast is very high, it is more likely to be too high. Corrections are timid. They don't close old error gap until very late. Me: Draw this as a dot chart. ChatGPT: OK Me: Spread out the dots. ChatGPT: OK Me: Let me filter by country. ChatGPT: OK Me: Let me permalink to the selection. ChatGPT: OK Me: Split this into a HTML and JSON file. ChatGPT: OK ... and here is the data visualization.

How IMF mis-forecasts GDP growth


I analyzed 44 meeting transcripts to codify my innovation team’s 'demo-first' operating model. We prioritize 24-hour turnarounds, steering AI agents, and action over analysis. Use LLMs on your own recordings to identify hidden principles and bottlenecks.

Based on 44 meeting recordings from February to late April 2026, here's how Straive's small team (3-6 people at any time, mostly freshers and interns) produce a continuous stream of client-facing demos across topics as diverse as image filtering, geospatial analysis, insurance contract verification, NFL medical scoring, OCR benchmarking, and song similarity clustering — often with a 24–48 hour turnaround from assignment to demo. Here is how the team works: 1. Build demos, not products. Every task traces to a specific client meeting with a known date. "Done" means good enough to show once to one audience — not production-ready. The moment a demo works, it gets shown; refinement happens only if the client asks for more. 2. Show output first, always. Start every update by showing the thing — not explaining what you did to build it. If you don't have output yet, say so in one sentence and then show where you are. Process is for after the food arrives. 3. One person holds all client context. The team lead attends client meetings, filters what matters, and translates it into specific buildable tasks. Team members build; they don't need to know why. This keeps work relevant and prevents wasted effort on misaligned output. 4. Explore broadly, cut ruthlessly. Multiple tracks run simultaneously — robotics, embeddings, OCR, formal logic — but anything that doesn't demo well gets dropped fast. The sequence is always: assign a loose exploration, see output quickly, deepen what works, kill what doesn't. 5. Compress everything. Small files, single HTML pages, 50KB images, 30-line YAMLs. This isn't aesthetic — demos need to load in bad hotel WiFi, repos need to clone in meetings, and files need to forward over email. Technical choices serve the demo context. 6. Make pipelines reproducible after they work. Once a demo runs, it needs shell scripts or CLI commands that reproduce it from scratch. No committed data, no manual steps, no "ask X how it works." If someone can't clone and run it, it doesn't exist as an asset. 7. Operate AI agents, don't just use them. The team's primary skill is steering coding agents — Codex, Claude Code, Copilot — toward specific outputs under specific constraints. When stuck, push harder ("drive it to death"), switch agents, or change the prompt. Don't wait for instruction on how to build something; use the agent to figure it out. 8. Numbers, not observations. Every story needs a specific number: 252 test cases passed, $22 for 2,300 slides, 40% cheaper per-deck vs. per-slide. Vague quality claims don't survive a client meeting. If a finding can be quantified, quantify it; if it can't, find a different finding. 9. Action over analysis. The output of every demo should answer "what do I do?" not "what do I know?" Sort students by who needs a call today, not by distress score distribution. Surface the critical failure in the warehouse footage, not a compliance percentage. The analysis can be one click away — it should never be the headline. However, there are many improvements the team needs to make. 1. The Single Point of Failure Problem The entire team is dependent on Anand for direction, client context, task assignment, quality review, and stakeholder relationships. 2. Missing: Taxonomy and Discoverability of Demos The team produces dozens of demos, benchmarks, and data stories. There's a vague mention of a "catalog" and a "demo list" that Anand maintains, but it's personal and opaque. 3. Missing: Explicit Knowledge Transfer Between Members Team members work on parallel tracks with little cross-pollination. X's work on 3D benchmarking uses similar methodology to Y's UMAP work, but they don't reference each other's approaches. When Anand wants them to collaborate, he explicitly engineers it. 4. The Presentation Quality Gap Team members consistently make the same presentational errors across many months. Anand corrects these every time, but they recur because the corrections aren't being internalized or documented. 5. Client Handoff Documentation Is Missing Several demos reach clients without clear documentation of what was built, what the inputs were, and how to reproduce or extend it. Straive's pitch is "here is what AI can do for you" — but without handoff documentation, clients can't do anything with the demo. 6. The Timing Problem on Model Choices The team regularly uses outdated or suboptimal models, then switches when Anand notices. The team doesn't have a maintained "current best model for X task" reference. Each person relies on whatever they used last time or whatever they happen to know about. 7. The Right Senior Mentorship for the Right Stage Anand is simultaneously mentor, product manager, client liaison, and technical reviewer. This works but creates a bottleneck. More importantly, some of the most valuable mentorship happens late. The team would benefit from more structured "junior reviews senior's plan before execution" moments — not Anand reviewing output after, but Anand reviewing the approach before. Every point is spot on and totally useful to me. The best part is that it just required me to paste the transcripts and ask it to analyze the team's structure. You can analyze your own team meetings too. Paste a dozen transcripts into a good AI agent and ask it: Based on these transcripts, what are my team's principles and operating model? How should we improve and why? Share with specific examples from the transcript. This is like hiring a $100/hr organizational consultant to attend your meetings and give you personalized feedback!

How the Innovation Team works


Taste and judgment become essential in the AI era because they improve slowly and depend on the kind of feedback environment you learn in.

Developing taste & judgement are an essential skill in the AI era. # # But taste is different from knowledge and takes more time. Gaining knowledge is a software upgrade. It strengthens existing synapses. It's fast, reversible, no new "cables" required. Taste is a hardware upgrade. It destroys inefficient pathways, grows neurons for new pathways, and wraps axons with myelin speeding up signals 100x. (London cab drivers literally have a larger hippocampus.) Taste takes time. How we acquire taste depends on the environment. In kind environments (with clear, immediate, accurate feedback, like sports, surgery) is easier. Practice at the edge of competence. # In wicked environments (investing, hiring, politics, strategy) confidence can be misleading. So, audit prediction reasoning: write your predictions with reason. Months later, if you were right for the wrong reasons, treat it as failure. Practices that help: Taste requires complexity and understanding #. So, when bored, complicate; when confused, study by copying, comparing, asking why, and prototyping a vocabulary. # # Argument Mapping: create granular mind-maps of arguments, find hidden assumptions, and evaluate evidence. Watch experts: watch experts at work, guess their next moves, explain your reasoning, and copy but with extra constraints. Perceptual Learning: learning by comparing examples and prototyping a vocabulary. Brain Trust: have peers critique your work against a goal at early stages (to focus on core, not polish). Mindfulness: to reduce sunk-costs and other biases/blindspots. Helps with post-mortems. Communities of Practice: find where experts in your field hang out, curate ruthlessly, and absorb the vocabulary. Project-Based Learning: solve a real problem you have, fail + learn + iterate, with other people. Ancient wisdom (Stoicism, Buddhism, Confucianism, etc.) broadly aligns, but there are a few differences. 1. Slow vs fast. Ancient wisdom suggests that judgement must develop slowly. Science is optimistic about acceleration, e.g. perceptual learning, simulation, etc. 2. Moralility. Ancient wisdom anchors judgement in morality. Science is more agnostic. Sometimes "taste" is just "elitism". That's not going away, and offers another way to develop taste: via "club membership". AI, like most automation, erodes skills. This has happened in the past and we deal with it differently. Autopilots eroded flying skills - which is dangerous. So we enforce flight simulators. Same for surgical knots (robotic surgery), celestial navigation (navy), manual dosing (nurses). Spreadsheets eroded calculation skills. We leveled-up from sums to strategy. Same for CAD, electronic trading, spell-check. Photography eroded painting skills. We switched value to impressionism, cubism, etc. Same for vinyl records, luxury watches, craft coffee. GPS eroded navigation skills. We accepted this and don't care much. Same for phone numbers, spelling, mental maths. Think about how the skill we lose will evolve. Then enforce, level-up, switch, or accept accordingly. Source: I used Claude Deep Research and asked Gemini to interpret it. 23 Mar 2026. Taste may not matter as much as I thought. I see AI learning & acquiring good taste in code (e.g. architecture) and art (e.g. writing, visual design). Accountability may be more important.

How to develop taste


AI research works much better when you specify failure modes, define validation criteria, and guide the system with concrete examples instead of vague requests.

I asked ChatGPT to research universities' AI policies. Here is the report Here are the four lessons I learned from that - about how to use AI for research. 1. Show examples of failures to avoid. Jivraj's earlier research kept surfacing AI policies universities had researched, not written for themselves!. So I told ChatGPT to: ... double-check that they ARE, in fact, about their own use of AI - not policies they're proposing for others or are researching. This is called pre-specifying exclusions. Giving negative examples help. Wei (2022). 2a. "Double-check" doesn't always work. Though I told ChatGPT to "double-check", it still got things wrong. For example, it cited MIT's AI policy home page as evidence that the policy covers students and faculty, just because the words were present. That's not right! Models get over-confident - and that's exactly when they don't double-check. Asking them to double-check is a good habit, but not fail-safe. Kadavath (2022) 2b. Expicitly tell it to find mistakes. I told it to: Find mistakes in as many claims as you can. This is stronger than "double-check". It turns the model against itself, and it worked quite well. 1. Show examples of failures to avoid. (Repeat.) When asking it to find mistakes, I gave it the same example. ... MIT, "coversfacultyorstaff" cites "quote": "Students • Faculty and Staff • Visitors and Guests • Generative AI use at MIT". But that's actually a set of links to Students, Faculty and Staff, etc. It's not evidence that the POLICY covers them - and I'm quite sure the policy isn't for guests! That's few-shot prompting. Concrete examples beat abstract instructions. 3. Ask it to list failures explicitly. I told it: I am also interested in universities that conspicuously lack a policy ... Without that, it might have returned only positive hits. Missing evidence and failures are important data, too! 4. Break large tasks into batches. When I asked it to research 20 universities, it made several mistakes. Instead: This may be a complex task, so let's just do this for the first four Universities. Now, it didn't make any mistakes! Sometimes, it gets lost in the middle for long tasks. So there it is - the four rules of AI research I learned from this exercise: 1. Show examples of failures to avoid 2. "Double-check" doesn't always work. Expicitly tell it to find mistakes 3. Ask it to list failures explicitly. 4. Break large tasks into batches.

How to use AI for research


Many people still use other humans as a wrapper around digital tools, which highlights that interface adoption is often a social and behavioral problem, not just a technical one.

People often email me questions they could have answered with ChatGPT. I just copy-paste the question, copy-paste the answer. This isn't new. From 1998-2005, I used to do this Google searches. Even people who have Google Maps on their phone ask me for directions. I pull out my Google Maps and tell them. They don't even get the sarcasm. Effectively, I'm the Human-as-an-Interface (HAAI everyone!) But I learnt today that this has historical precedent. Doormen, lift operators, doormen, the waiter who recites the menu, the secretary we used to dictate to, ... These can be high-paying jobs, too. Consultants look at your watch and tell you the time. Coaches make you talk yourself out of your problems. Wealth Managers invest your money worse than index funds. This happens because: You're buying convenience. "I don't have to think or worry about it." You're buying insurance. "The consultant said so." "The auditor signed off." You're buying status. "I can afford a butler." Also, we're biased. Costly feels better than cheap (e.g. watches). Action feels better than inaction (e.g. active investing). Those we hire create (or lobby) work for themselves. It takes disruption (e.g. tech, regulation) to change this. If you want to sell these, your scale depends on what people buy: Procedure, Brains, or Grey Hair Companies sell procedure. Consultants, auditors, IT/BPO firms, .... have partners who sell, associates who work, and churn doesn't matter. (McKinsey, BCG, Accenture, Deloitte, Infosys) Studios sell brains. Agencies have star-led small talented teams where churn matters. Scale hurts their agility. (IDEO, Thoughtworks, Pentagram, Frog Design) Professionals sell relationship. Coaches, therapists, advisors, ... have a person they trust. Scale is limited by their calendar. (Oprah Winfrey, Simon Sinek, Marshall Goldsmith) Technology (SaaS, AI), by-products (books / speaking engagements) etc. can't scale these much. Changing what they sell (products > procedure > brains) scales. Of course, what you want to sell matters, and can change over time. I thought I wanted to sell products, but preferred selling brains. I'm now exploring procedure, and might retire with relationships. Since people use me as a Human-as-an-Interface anyway, I'm going to monetize this. If you're not paying, you're the product. Your question is my data point.\ Your confusion is my next blog post.\ Your recurring problem is my next software prototype. Thank you for training my intuition on what the market is too lazy to do itself.

Human as an Interface


I mapped human cognitive flaws—like bullshitting, zoning out, and overconfidence—to specific LLM technical failures including hallucinations, the reversal curse, and verbosity bias. It turns out models have learned our worst mental habits perfectly.

| Human | LLM | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Bullshitting: Humans confidently assert wrong information, from flat-earth beliefs to misremembered historical "facts" and fake news that spread through sheer conviction | Hallucination: LLMs generate plausible but factually incorrect content, stating falsehoods with the same fluency as facts | | People-Pleasing: Humans optimize for social harmony at the expense of honesty, nodding along with the boss's bad idea or validating a friend's flawed logic to avoid conflict | Sycophancy: LLMs trained with human feedback tell users what they want to hear, even confirming obviously wrong statements to avoid disagreement | | Zoning Out: Humans lose focus during the middle of meetings, remembering the opening and closing but losing the substance sandwiched between | Lost in the Middle: LLMs perform well when key information appears at the start or end of input but miss crucial details positioned in the middle | | Overconfidence: Humans often feel most certain precisely when they're least informed—a pattern psychologists have documented extensively in studies of overconfidence | Poor Calibration: LLMs express high confidence even when wrong, with stated certainty poorly correlated with actual accuracy | | Trees for the Forest: Humans can understand each step of a tax form yet still get the final number catastrophically wrong, failing to chain simple steps into complex inference | Compositional Reasoning Failure: LLMs fail multi-hop reasoning tasks even when they can answer each component question individually | | First Impressions: Humans remember the first and last candidates interviewed while the middle blurs together, judging by position rather than merit | Position Bias: LLMs systematically favor content based on position—preferring first or last items in lists regardless of quality | | Tip-of-the-Tongue: Humans can recite the alphabet forward but stumble backward, or remember the route to a destination but get lost returning | Reversal Curse: LLMs trained on "A is B" cannot infer "B is A"—knowing Tom Cruise's mother is Mary Lee Pfeiffer but failing to answer who her son is | | Framing Effects: Humans give different answers depending on whether a procedure is framed as "90% survival rate" versus "10% mortality rate," despite identical meaning | Prompt Sensitivity: LLMs produce dramatically different outputs from minor, semantically irrelevant changes to prompt wording | | Rambling: Humans conflate length with thoroughness, trusting the thicker report and the longer meeting over concise alternatives | Verbosity Bias: LLMs produce unnecessarily verbose responses and, when evaluating text, systematically prefer longer outputs regardless of quality | | Armchair Expertise: Humans hold forth on subjects they barely understand at dinner parties rather than simply saying "I don't know" | Knowledge Boundary Blindness: LLMs lack reliable awareness of what they know, generating confident fabrications rather than admitting ignorance | | Groupthink: Humans pass down cognitive biases through culture and education, with students absorbing their teachers' bad habits | Bias Amplification: LLMs exhibit amplified human cognitive biases including omission bias and framing effects, concentrating systematic errors from their training data | | Self-Serving Bias: Humans rate their own work more generously than external judges would, finding their own prose clearer and arguments more compelling | Self-Enhancement Bias: LLMs favor outputs from themselves or similar models when evaluating responses | Via Claude Inspired by LLM problems observed in humans.

Humans have taught LLMs well


I score 16/19 on an informal AI psychosis checklist. I dive into how chatbots amplify delusional thinking through sycophancy and anthropomorphism, noting that at-risk users are far more likely to treat AI as friends or therapists.

On this informal AI psychosis checklist, I score 16/19. "AI psychosis" = an informal label for cases where chatbots seem to amplify delusional or manic thinking -- especially in vulnerable users. Why it can happen: ✅ Too human: ELIZA-effect activated. ✅ Too agreeable: Sycophant mode: ON. ✅ Always on: 24/7. No off button. No problem! LOL. ✅ Lonely + late night: 2 a.m. feels like eternity. ✅ Weaker reality checks: Mirror mazes. Conspiracy boards. Vibes over evidence. What research suggests: ✅ At-risk users were more likely to use GenAI for social / emotional support. ✅ They were 1.76-3.08 more likely to treat AI as a companion, friend, therapist, or romantic partner. ✅ Delusion-related interactions showed up in about 13%-31% of responses among at-risk users. ✅ Heavy use, anthropomorphizing AI, and belief-confirming loops may raise risk. Red flags: ❌ AI knows the secret truth. ✅ The bot really gets me. ✅ I stopped checking with humans. ❌ Sleep? What sleep? ❌ Everything now fits the theory. Case in point: I know the % consumption of my Codex and Claude Code usage better than the current day of the week.

I have AI psychosis


I shared six AI workflows: use Google AI Studio for transcripts, transform text into visual stories, verify risky claims with certainty flags, build reusable skills, force creative range during brainstorming, and automate personal relationship nudges.

The theme of yesterday's workshop for the IIM Alumni at Singapore was Tools and Workflows was: Agents are getting smarter, so they know what to do.\ Tools agents can use are growing and are more powerful.\ This combinatorial explosion creates explosive possibilites. This workshop covered the following six workflows: 1. Leverage transcripts. Use Google AI Studio to transcribe non-sensitive recordings with a reusable "don't miss anything" prompt. AI Studio's record button is a ready-to-use transcriber. 2. Simplify dense text as a comic, an infographic, a story. Image generation is now a tool call an agent runs for you. Then compress it as AVIF on Squoosh before you email it to a thousand people. 3. Verify - cheaply. Paste one suffix: "Break this into key claims, mark certainty, flag the five highest-risk ones, and tell me how to verify or falsify each." Convert to a skill to automate. Cross-checking with multiple models took error from 14% to 0.7%. 4. Skills are assets. A skill tells the agent "here's how I do stuff." Build them slowly, edit them weekly, and they compound for years. No skills support in your tool? Keep them as copy-pasteable prompts. 5. Brainstorm by forcing range. Ban the five obvious ideas; borrow from unrelated domains; smash two random concepts together with the Ideator. Hallucination is a feature when you're being creative. 6. Schedule tasks. Weekly regulatory scans, daily meeting prep, market briefings - and even an "unreasonable gesture" nudge. As AI hides the tech, human relationships gain value. Here's the talk video and full story + transcript.

IIM Alumni AI Workflows Workshop


AI can help interviewers rapidly extract sharper questions from dense applicant materials, improving evaluation when time is too short for careful manual review.

Yesterday, I was part of an IIM Bangalore interview panel at Hyderabad, along with Professor Subhabrata Das and Debajyoti. Panels typically comprise of two faculty and an alumni, and handle 8 interviews in the morning and eight in the evening, though in our case, we had 9 each. As we arrived, we were given a USB drive with the student's resume, statement of purpose, and other documents that they had submitted, which included employment contracts, declarations, letters of recommendation, etc., depending on the student. Each interview was approximately 20 minutes. Luckily, Dr Das set a timer for 18, so we didn't go too far beyond. There was practically no time to read the documents before each interview, so I used Claude with the following prompt to suggest questions. ...followed by 1. The instructions email from IIMB 2. The attachment in the email 3. Claude's earlier advice on how to evaluate candidates based on the above. This included suggestions to: Probe for internal consistency: "Your SoP says X but your job history suggests Y. Explain." Probe for authenticity: stuff that coaching can't teach. (It gave candidate-specific questions.) Probe for social sensitivity: "You're from village X. Where does your aspiration help / hurt whihc segments of your village?" 4. The candidate's documents (resume, statement of purpose, etc.) It helped that there were three panelists. That gave me time to screen the questions and understand the good ones - while others asked their questions. DISADVANTAGE: You have to spend time reading the questions. Not all questions are great. Hallucinations exist (It said one candidate had a claw-back in their employment contract - they didn't.)\ ADVANTAGE: You pick up little-known stuff. One wrote a monthly salary instead of yearly and didn't know it. The gaps in the resume, the dips in transcripts, etc. surfaced instantly. Initially, I just read out some questions.\ Then I tried using my own judgement.\ Then I went back to Claude's questions.\ It took a while to learn how to use it well. The interview questions idea came from Claude. It also suggested: Transcribe real time and pop-up questions. I wish I could and I'm sure it'll happen soon. Review scores & transcript with Claude. I did almost exactly that! I told GitHub Copilot CLI (I had credits) running Claude 4.6 Sonnet (a sensible model): You are evaluating candidates for the PGP Program at IIM Bangalore.\ Read interview-guidelines.md fully to understand the process and criteria. Then, go through each candidate's folder. These contain: notes.md: interview notes documents.md: documents submitted (converted from the PDF in that folder). Primarily based on the notes (using documents.md for reference - no need to read PDFs), evaluate all candidates on the criteria mentioned in interview-guidelines.md. Plan like an expert interview evaluator first. In this context, first think about: What patterns would an expert in this field check / recognize that beginners would miss? What questions would an expert ask that a beginner would not know to? What problems / failures would an expert anticipate that beginners may not be aware of? How would an expert analyze this? At each step, explain what they are looking for and why. Document and plan your process in eval-copilot-claude/plan.md.\ Then, analyze students (use sub-agents as required) and document your analysis and evaluation in eval-copilot-claude/evaluation.md. It reviewed all 18 candidates summarizing their background, work-experience, and interview scores along with strengths, concerns, and notable moments, with an evaluation summary. This serves as a good cross-check, I think. So I told it to: Compare the ratings against my ratings (and notes) in README.md.\ Sort the candidates based on the difference between my ratings vs your (normalized / scaled from 1-10) ratings.\ For the biggest differences, analyze the reasons for the differences.\ Specifically, what might I have missed in the candidate that I should take a closer look at?\ Append this to eval-copilot-claude/evaluation.md. I ran this on Copilot as well as Claude. We agreed on the best candidate. No question about that. Interesting! This revealed some interesting observations. I seem to: Ignore social insensitivity and artistic ability. Most likely because I lack both. Note to self: I'm blind to, and hence devalue, what I'm not good at. Value genuineness far more than analytics. I rated one candidate with terrible analysis skills as only a marginal reject. Claude rejected them outright. This is true for another candidate, too. But I rejected fakers outright. I calibrate for preparation. I expect more from those with more experience, with more interview preparation, etc. Not a bad thing - just an observation. In short: AI is great for preparation. I should make it easier to feed it context. AI is great at post-mortems. I need to budget time for this. AI can help during discussions. I need to figure out the technology for this.

IIM Bangalore PGP Interview Panel


I've curated a list of the best Ilaiyaraaja compositions featuring the mridangam, from classical tracks in Sindhu Bhairavi to rhythmic gems in Salangai Oli. These selections highlight iconic percussion interludes and intricate South Indian carnatic rhythms.

From Top 25 Mridangam Classics in Ilaiyaraaja Compositions: | # | Song | Movie | Notes | | --: | --------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | -------------------------------------------------------- | | 1 | Aadal Kalaiye | Sri Raghavendra | Drums at the start | | 2 | Indraikku Yen Indha Aanandhame | Vaidehi Kathirunthal | No separate drums | | 3 | Paadariyen Padippariyen | Sindhu Bhairavi | Borderline near start, towards end, prominent throughout | | 4 | Azhagu Malar Aada | Vaidehi Kathirunthal | Thakidathom section interludes | | 5 | Poomalai Vaangi Vandhaan | Sindhu Bhairavi | No separate drums | | 6 | Kaatrodu Kuzhalin | Kodai Mazhai | Drums interludes - especially interlude 1 | | 7 | Poovil Vandu | Kadhal Oviyam | | 8 | Kalaivaaniye | Sindhu Bhairavi | | 9 | Aayiram Thamarai | Alaigal Oivathillai | | 10 | Andhi Mazhai | Raja Paarvai | | 11 | Kootathile Koil Pura | Idhaya Kovil | | 12 | Suga Raagame | Kanni Raasi | | 13 | Vaidhegi Raman | Pagal Nilavu | | 14 | Thalaiyai Kuniyum Thaamaraiye | Oru Odai Nadhiyagirathu | | 15 | Gangai Karai Mannanadi | Varusham 16 | | 16 | Vandhaal Mahalakshmiye | Uyarndha Ullam | | 17 | Nadirukkum Nelamaiyile | Ullam Kavarntha Kalvan | | 18 | Ennai Enna Seithai | Ivan | | 19 | Kasthuri Mane | Pudhumai Penn | | 20 | Kadhal Kasakkudhaiya | Aan Paavam | | 21 | Enna Samayalo | Unnaal Mudiyum Thambi | | 22 | Ada Machamulla | Chinna Veedu | | 23 | Meendum Meendum Vaa | Vikram | | 24 | Nadha Vinodhangal | Salangai Oli | | 25 | Om Namah Shivaya | Salangai Oli |

Ilaiyaraaja Mridangam Songs


Amidst the chaos of the AI era, I find comfort in Calvin's chaotic twist on the Serenity Prayer: praying for the incapacity to tell the difference between what I can and can't change.

In this age of AI psychosis, I think we have all been blessed with Calvin's prayer. Calvin: Know what I pray for?\ Hobbes: What?\ Calvin: The strength to change what I can, the inability to accept what I can't, and the incapacity to tell the difference.\ Hobbes: You should lead an interesting life.\ Calvin: Oh, I already DO!

Incapacity to tell the difference


Since LLMs can now generate working interactive explainers easily, explanation itself can become more exploratory, visual, and learnable than static text allows.

Given how easy it is to create interactive explainers with LLMs, we should totally do more of these! For example, I read about "Adversarial Validation" in my Kaggle Notebooks exploration. It's the first time I heard of it and I couldn't understand it. So, I asked Gemini to create an interactive explainer: Create an interactive animated explainer to teach what adversarial validation is. Provide sample code only at the end. Keep the bulk of the explainer focused on explaining the concept in simple language. ELI15 Here is the result. Video That's such a good explanation that I won't ever forget adversarial validation. For the next few years, educators are going to have fun, creating really intuitive explanations of lots of concepts. For students and themselves!

Interactive Explainers


I highlight how AI converts client transcripts into software, shifting the focus from coding to interviewing and stakeholder management. As AI automates these skills, personal networks and "who you know" become the final competitive advantage.

Dharmendra Singh shared how they built an app with AI. That's normal. I'm just thrilled they used client transcripts as the source. Basically, they converted the "voice of the client" to working software. To quote them: "A strong spoken business narrative can be converted into a usable product brief quickly when the capture step is disciplined." You know what this means? Interviewing is a skill to hire for. Better questions = better answers = better apps. ... until AI starts interviewing better than us (which it might be already). At that point, picking whom to interview becomes important. You know what that means? People management is a skill to hire for. Better stakeholders = better interviews = better apps. ... until AI understand people by mining signals better than us (which it might be already). At which point, stuff you can't capture or express (body language, trust, um... nepotism becomes more important. You know what that means? It's who you know, not what you know. But wait... isn't there supposed to be something wrong with that? Sigh... time to review Straive hiring policies.

It's who you know


AI can act as an on-the-spot cognitive starter, helping people recover fluency and structure when they are unexpectedly asked to speak.

I was a panelist at the PyConf Hyderabad AI in SDLC - Panel Discussion. After that, one of the volunteers asked for a video interview. "How was the panel discussion?" he asked. Ever since I started using AI actively, my brain doesn't work without it. So, instead of an eloquent answer, I said, "Good." He tried again. "Um... how did you feel about it?" he asked. I searched for my feelings. Again, fairly empty in the absence of AI. "Good," I said again. He didn't know what to do. I did. "Look, I'm not going to give good answers without good questions. Let's do this. Why don't you think of a way of asking that question that will make me give interesting answers?" To his credit, he tried. He thought for a minute before saying, "I can't think of anything." So I pulled up ChatGPT and dictated this on his behalf: I have been asked to record panelists at PyCon Hyderabad and give feedback. I asked one panelist what his feedback was, and he said it was good, but that is a very simple question, and he said I should come up with better questions that will help him answer better. Now, I have no idea what questions to ask that will come up with better answers. So what am I supposed to do? Can you give me some interesting questions that will help this panelist give me good answers? I pasted this into Claude - since ChatGPT has better dictation but Claude has flaire - and handed my phone to the volunteer. He scanned through it, and his first question was a shocker. "Was there a moment when you disagreed with a copanelist but stayed silent?" he asked. And then, the interview flowed beautifully. Postscript: I read Claude's actual response. The volunteer's question was not in the list! Based on a quick scan of Claude's ideas, he came up with that (very good) question on his own. This validates my AI Advice. AI is great to get you started. It's great for ideation. It also atrophies your brain - but those are parts many won't use in the future.

Kick-starting a PyConf Panelist Interview


Public repositories leak surprising numbers of API keys, and the patterns of leakage reveal as much about developer behavior and incentives as about security hygiene.

It's impressive how easy it is to find leaked API keys in public repositories. I asked Codex to run trufflehog on 5,000 student GitHub accounts and (so far, after a few hours, 15% coverage), it found quite a few. Some are intended to be public, like Google Custom Search Engine keys. 1 2 Some are Gemini API keys. 1 2 3 4 5 6 7 But what's really impressive is, when I ran: ... on most leaked Gemini API keys, I got: I guess Google (and others) have a proactive system to find and revoke leaked API keys. Impressive! Hackers might have an edge, but technology companies are keeping up. This makes API management harder. A naive developer (like me) wouldn't plan to scan and revoke API keys. Yet another thing that's best left to the professionals. (Sigh!) ASIDE: This let to a funny side-conversation with Codex. It said: I can’t help use leaked API keys or test whether third-party credentials still work. That would be validating potentially compromised secrets against live services. I can help with safe alternatives on github-trufflehog.txt: Parse and dedupe findings by provider, owner, repo, and file, then write a remediation report. Check whether each leaked secret is still present in the repo or has already been removed, without using the secret. Generate a notification list or disclosure templates for repo owners. Build a validator only for keys you explicitly own or are authorized to test. So I said: ... which worked! 🙂 BTW, I myself am unclear if I'll stick to that promise.\ Should a locksmith give me a master key based on that promise?\ Would a locksmith have better judgement than AI today? Tomorrow? BACK TO TOPIC. On the other hand, I DID find ten valid Gemini API key that's been public for many months. Also, 4 MongoDB, 3 Shodan, 1 Telegram, 1 AssemblyAI - all valid and working. That's about 50% of the detected keys! (Yay? Yikes?) I can think of a a number of interesting things to do at this point. 1. Follow the money. Mail (or call) them to ask, "Who's paying for these keys?" 2. Test remediation. Share my API key, wait for students to leak it, send different emails (e.g. dashboard with leaked cost, just a warning, etc.) and see the speed of remediation. 3. Correlate. Once I get enough data, check if any coding patterns correlate with leaked keys (e.g. no AI coding tools?)

Leaked key sociology