data-visualization on S Anand

How IMF mis-forecasts GDP growth

Mon, 22 Jun 2026 10:41:30 +0800

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.

Data Stories with AI Workshop

Mon, 08 Jun 2026 16:26:32 +0530

On Sat 13 Jun 2026 at 3 pm, I conducted an online workshop on Data Stories with AI.

Registration link: https://forms.gle/dNkUxtJ2PVqNMNcE9

In this workshop, the audience used ChatGPT and Claude, mostly, to:

Find data
Analyze it
Extract insights
Visualize as stories

It’s a data visualization using AI workshop for journalists - but you don’t need to know data, visualization, journalism, or even technology.

But this is a practical workshop. You’ll be doing stuff and sharing your results.

Pre-requisites: A paid ChatGPT Plus or Claude Pro account - both are about Rs 2,000. Just buy it for a month. It’s worth it.

It’s on Google Meet: https://meet.google.com/qzt-obnb-cgp.

Here are the takeaways from the workshop:

Delegate the prompt, not just the task. Don’t write the brief — hand the model your examples and ask, “What prompt should I give you to do this?” Meta-prompting is laziness turned into method.
Treat “stuck” as a prompt. Write down exactly where you’re stuck and paste it in. You either get unstuck, or you get stuck on something new. You never stay stuck — the bottleneck keeps shifting.
Never let the model do arithmetic in its head. Say “write and run a program to do X.” It can’t reliably multiply nine-digit numbers, but it can write code that checks a million possibilities exactly. Arithmetic as a tool, not as memory.
Low-cost experiments are free insight. “Blow my mind with insights nobody would know” costs nothing. If it’s good, bonus. If it’s wrong, you lose nothing. Start with what’s easy, learn what works, then scale.
“Check what is missing,” not “is this correct?” Asking a model to confirm makes it lazy. Asking it to find errors — “the more errors you find, the better” — makes it useful.
New topic, new chat. Models have no memory; they replay the whole conversation each time. A two-hour thread asked to “do X” is a confused assistant. Stuck in a loop? New chat, new model, new provider.
Ask for a single-page HTML file. It’s the most shareable, chart-capable output. For impact, also try “create an image” — comics, infographics and sketchnotes are now serious analytical formats.
Feedback is the new main event. Generation and verification are cheap, so spend your effort on iteration. A reader’s one-line objection — or an AI pretending to be the audience — becomes a revision in seconds.
Beware the false positive. “Vanishing water” can mean a lake being cleaned; “less vegetation” can be removed algae. Let the model research the cause — and give it the power to say “no story here.”
Pay for one month, then judge. ₹2,000 of Plus, used hard for 30 days, is the highest-ROI tech subscription there is. Re-evaluate every six months — never longer — because everything is accelerating.

Wikipidia Citation Impact

Thu, 28 May 2026 10:00:58 +0800

Imagine you’re an information anarchist. You undermine Wikipedia pages by nuking references.

A genie has granted you a wish: you can nuke one entire domain. Just one.

As a data-driven decision maker (who is also an information anarchist 🤷), which would you pick?

A common choice is The Internet Archive. 2.9 million Wikipedia pages reference it.

But, you’re sneakier than that. A page isn’t undermined just because some references are gone. It’s undermined when all the references are gone.

In that case, the most devastating domain to nuke is Statistics Poland. Over 45,000 Wikipedia pages cite only Statistics Poland as their reference.

Or, if you’re particularly fond of the Polish, destroy sports-reference.com. Over 37,000 pages cite it as their only reference.

If you prefer hurting scientists, go for biolib.cz - an online encyclopedia of plants, animals, and very importantly, fungi. (But then, you don’t need to nuke it - the “server is experiencing high traffic” quite often.) In any case, this is where you’ll find most satisfaction, as more sites depend solely on biodiversity and natural history archives like marinespecies.org (WoRMS), Natural History Museum, IUCN Redlist than any other category.

For detailed research on which site you’d like to nuke, see What If a Website Just Died?

Calvin UMAP

Fri, 20 Mar 2026 21:42:38 +0530

Similar to the embedding map of my blog posts, I created an embedding map of Calvin & Hobbes. It uses the same process as before.

Video

Interactive Explainers

Tue, 17 Mar 2026 13:57:54 +0530

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!

Blog embeddings map

Sun, 15 Mar 2026 23:22:46 +0530

I created an embedding map of my blog posts.

Each point is a blog post. Similar posts are closer to each other. They’re colored by category.

I’ve been blogging since 1999 and over time, my posts have evolved.

1999-2005: mostly links. I started by link-blogging
2005-2007: mostly quizzes, how I do things, Excel tips, etc.
2008-2014: mostly coding, how I do things and business realities
2015-2019: mostly nothing
2019-2023: mostly LinkedIn with some data and how I do things
2024-2026: mostly LLMs

… and this transition is entirely visible in the embedding space.

Video

I used Codex and GitHub Copilot + Claude Sonnet 4.6 to create this visualization. It was vibe coded in the background while I was vibe-coding my PyConf Hyderabad talk. The rough process was:

Extract the blog posts and pages (stripping out comments, adding titles).
Use Gemini Embedding 2 Preview to generate 768-dimentional embeddings for un-embedded content.
Create a UMAP visualization of these embeddings, colored by category, and make it interactive with filters and popups.

Protyping the prototypes

Tue, 10 Mar 2026 12:17:47 +0800

I added a narrative story to my LLM Pricing chart. That makes it easier for me and others to tell the story of AI’s evolution in the last three years.

Video

It was vibe-coded over two iterations.

In the first version, I prompted it to:

Add a scrollytelling narrative. So, when users first visit the page, they see roughly the same thing as now (but prettier). As they scroll down, the page should smoothly move to the earliest month, and then animate month by month on scroll, and explaining the key events and insights in terms of model quality and pricing. Use the data story skill to do this effectively, narrating like Malcolm Gladwell, with the visual style of The New York Times, using the education progression as a framework for measure of intelligence (read prompts.md for context). Store the narrative text in a separate JSON file and read from it. This should control the entire narrative, including what month to jump to next, what models to highlight, what insights to share, and so on.

But there were two problems:

Conflicting instructions. “… with the visual style of The New York Times” conflicted with my current style.
Incomplete instructions. I wanted to begin with the exploration, not the narrative. I wanted to explain the axes first. I wanted smaller cards.

Both of them were solved in the second version, because this time, I knew what I wanted.

In other words, vibe coding isn’t just helping me prototype, it’s helping me prototype the prototype! Even if I don’t know what I want, I can just ask for something and build on it.

This is a known benefit of lower costs. But, like the placebo effect and Hofstadter’s Law, I’m surprised by it even when I know it.

An aside: Here’s the narrative it crafted:

How to read this chart: The vertical axis is intelligence — mapped to the academic ladder on the right. Elo 1100 is high school freshman; Elo 1480 is tenured professor. The horizontal axis is cost: one million input tokens — roughly the entire King James Bible — priced from two cents to $75. The upper-left corner is the dream: brilliant and cheap. This is the story of how the world got there.
March 2023 — Year Zero: March 2023. The entire AI landscape fits in a small cluster near the bottom of the chart. GPT-3.5 and Claude 1 are the state of the art — high-school-to-college-freshman intelligence that writes a fluent paragraph, then confidently invents a fact. Processing the King James Bible costs 50 cents to $8. These models can hold a conversation. They cannot, reliably, hold an argument. LMSYS Chatbot Arena launches (May 2023)
November 2023 — The Leap: November 6, 2023: GPT-4 Turbo. The chart jolts upward. Elo 1313 — college-junior level: coherent research papers, complex reasoning, output worth reading. Price: $10 per million tokens — about $14 to process all seven Harry Potter novels. Expensive, but for the first time the intelligence felt worth it. Enterprises stopped asking whether AI could help. They started asking how much they were willing to pay. OpenAI DevDay announcement
February 2024 — The Split: Early 2024: Anthropic launches Claude 3 in three tiers. Opus and Sonnet arrive February 29; Haiku a week later, March 7. Opus: entry-analyst capability at $15. Sonnet: similar quality at $3. Haiku: college-junior reasoning at $0.25. A 60× price spread — same company, same training philosophy. The intelligence market had learned to stratify, and every business began thinking in tiers. Anthropic Claude 3 announcement
June 2024 — The Summer Pivot: June 2024 bent the economics permanently. Claude 3.5 Sonnet — strong manager level (Elo 1342) — arrived at $3 per million tokens: five times cheaper than Opus, four months later, at better quality. Meta’s Llama 3.1 405B matched it at $2, or free if self-hosted. Any CFO paying $15 for frontier AI could now pay $3. The question changed from “can we afford AI?” to “what are we waiting for?” Claude 3.5 Sonnet launch, Meta releases Llama 3.1
September 2024 — The Thinking Machine: September 2024: OpenAI o1. It didn’t just answer — it reasoned. Before responding, it ran an internal monologue: checking its own logic, catching its own errors. Elo 1388 — the biggest single-model quality jump since GPT-4. It scored at or above PhD-expert level on GPQA Diamond, a benchmark of graduate-level science questions. Price: $15. For the first time, AI felt less like autocomplete and more like a colleague you’d genuinely consult. OpenAI o1 system card, GPQA Diamond benchmark results
January 2025 — The Earthquake: January 20, 2025. DeepSeek R1 matched o1-level reasoning (Elo 1398) at $0.55 per million tokens — a 27× discount. The announcement wiped $600 billion from Nvidia’s market cap in a single day. Silicon Valley assumed expensive compute was a moat. DeepSeek proved it was just a starting point. PhD-approaching reasoning for fifty-five cents per Bible. Reuters: DeepSeek wipes $600B from Nvidia, DeepSeek R1 technical report
Mid-2025 — The Race to the Top-Left: By mid-2025, the upper-left corner was filling fast. Gemini 2.5 Pro delivered tenured-professor intelligence (Elo 1476) at $1.25 per million tokens. Flash models handled most enterprise work for 30 cents. Companies that had rationed AI to critical workflows were now running it everywhere. The constraint was no longer cost or capability — it was imagination. Google Gemini 2.5 Pro launch
February 2026 — Polymath Scholar: The top models in early 2026 score above 1500 Elo — polymath scholar territory. A 1500-rated model beats a 1300-rated one in 76% of head-to-head matchups. GPT-4 Turbo launched at college-junior level (Elo 1313) in November 2023. Twenty-seven months later, Claude Opus 4.6 and Gemini 3.1 Pro sit at 1500+. What cost $15 in 2024 is now beaten by models at one-seventh the price. LMArena Leaderboard
So What Does This Mean?: In 2023, reaching master’s-level AI for 100 analysts meant paying $30/MTok — roughly $135,000 a month. By 2026, models with higher capability cost $1–5/MTok: under $15,000 for better results. For most tasks — analysis, drafting, coding, research — models in the $1–3 range deliver more than enough. Save frontier models for your hardest problems. The question is no longer what AI costs. It’s what you would build if intelligence cost a dime per Bible. McKinsey: The economic potential of generative AI, Sequoia: AI’s $600B question

Self-referentially, my answer to its last question: “what you would build if intelligence cost a dime per Bible” is “a scrollytelling narrative about intellegince costing a dime per Bible”.

Can AI discover new data visualizations?

Sat, 14 Feb 2026 15:15:52 +0800

Here’s my talk proposal for VizChitra 2026:

Description

There’s stuff I know AI can do.

Create data visualizations. I just tell it to convert a dataset into a treemap, and it does.
Hallucinate. That’s a fancy word for “make stuff up”. I prefer calling it “creativity”.
Run forever. As long as I have token budget and can summarize the context, it can go on.

What if we combine these? What if we asked it to do research? If infinite monkeys will almost surely produce Shakespeare, how long will it take for the greatest AI to discover a truly novel data visualization that is useful?

This isn’t a talk. It’s an exhibition.

I’m not presenting. My AI monkeys are. They’ll show off what new data visualizations they’ve discovered, given the following constraints:

It’s novel. Check and make sure it’s stuff we haven’t seen before.
It’s useful. It has to reveal insights from data (even a niche kind).
It’s beautiful. Visually striking and engaging.

My role will just be a narrator of their work - since they can’t speak (or… um… )

Actually, my role is an admirer and critic - since they can’t critique themselves (but… actually… )

Well, I’m the person who paid for their tokens and will therefore take credit on stage. So there.

Video

Links:

About the speaker

Anand’s an LLM psychologist @ Straive. He prods AI to understand how it thinks. It prods back, teaching him how HE thinks. He’s ex-IITM, IIMB, INFY, LBS, IBM, BCG & other TLAs. He transcribed every Calvin & Hobbes strip over 7 years. AI does that now in 7 min.

Creating data stories in different styles

Fri, 09 Jan 2026 17:20:00 +0800

TL;DR: Don’t ask AI agents for one output. Ask for a dozen, each in the style of an expert. Share what works best.

AI agents build apps, analyze data, and visualize it surprisingly well, these days.

We used to tell LLMs exactly what to do. If you’re an expert, this is still useful. An expert analyst can do better analyses than an AI agent. An expert designer or data visualizer can tell an AI agent exactly how to design it.

But you’re not an expert in everything.

Instead, “style transfer” experts.

LLMs are trained on the styles of experts across the world. Tell them to adopt an expert’s style. That’s a shortcut to improve output quality. It won’t be as good as that expert, but likely better than you.

For example, Linux Foundation leaderboards evaluates open source projects - are they active, who’s behind it, do they follow security best practices, what’s their popularity, etc.

Varun use GitHub Copilot with GPT-5 mini to scrape the data Then, he had Claude Opus 4.5 create data visualizations in five different styles:

A Wall Street Journal style. Prompt
Malcolm Gladwell + NYT style, i.e. written in Malcolm Gladwell’s voice (who writes for the New Yorker), but with the New York Times’ visual style. This ability to remix is powerful. Prompt
The Polygraph / The Pudding style. We aren’t specifying a single publication here, but providing multiple publications, allowing it to mix and match from those. Prompt
From Shirley Wu, who is a data artist, allowing us to go to the style of a specific individual. Prompt
An “open source data adventure”. That’s not a publication or a person, but a theme. Prompt

Same input. Five different styles.

For example, while The New York Times comes up with transitional scatter plots (which are great for rich interactive explorations):

… Shirley Wu comes up with these hidden gems, focusing on the smaller projects that have a remarkably diverse contributor base.

Or, while The Wall Street Journal opens with the state of the economy:

The open-source software that underpins trillions of dollars in global commerce is showing signs of strain.

… Malcolm Gladwell opens with perspective:

In the spring of 2023, a small project called CBT Tape caught my attention. Three contributors. That’s it. Yet they had pushed 3,414 commits in twelve months—a rate of 1,138 commits per person. To put that in perspective: a “normal” project sees perhaps 20-30 commits per contributor annually.

At least for the next few years, the ROI is less from expertise. It’s more from style.

Try out different styles. Learn to guide AI towards your preferences. Pick what works best.

And share!

The Jamnagar Chokepoint - Data Story

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

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

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

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

Here is the data story.

Here are the prompts used.

Analyze

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

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

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

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

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

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

Visualize

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

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

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

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

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

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

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

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

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

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

Tue, 23 Dec 2025 05:36:05 +0000

I used to be a data visualization expert. I’m not sure I still am.

When Anthropic published an article about how AI is transforming their engineers’ work, I ran this prompt:

Suggest how the following engineer productivity patterns can be illustrated using interactive animated charts, graphs, or infographics.

Be diverse. Xenographics are welcome. Novel animation* / *interaction styles, artistry, xenographics, and diverse chart types are encouraged.

Be intuitive. A single glance should tell them exactly what insight we are trying to convey.

Its suggestions were better than mine.

Gemini 3 Pro was the best, followed by Claude (Opus/Sonnet 4.5) and then ChatGPT (GPT 5.2). They came up with:

a Throughput Flow showing commits as particles, going from a trickle to a stream
a Knowledge Neural Net where an engineer’s mental model transforms from isolated clusters into a dense mesh
a Dark Matter Radar detecting invisible tasks, a Feedback Pulse, a polyomino task stacking
… and more.

I have ~20 years of professional data visualization experience. I teach it. And these AIs just casually suggested more creative visualization ideas in 10-30 minutes than I probably would have come up with in a day.

This cost less than $2. The new per-day-rate for my expertise, I guess.

Luckily: my expertise has two parts.

Part 1: Ideating innovative visualizations.
Part 2: Selecting the right one for the job.

AI’s better at ideation. It’s fast and can generate creative ideas faster than I can sketch on a whiteboard. It knows xenographics and every visualization ever made and can recombine them in novel ways.

I’m better at selection. For now. Knowing which visualization requires knowing the audience, context, and intent. It requires taste (accumulated wisdom from showing the wrong chart to the wrong audience enough times).

But still, since AI can ideate, anyone can create innovative visualizations. No 20-years of experience, reading Edward Tufte’s books, or comparing a violin plot and a beeswarm. Just tell the story and AI will suggest ten creative ways to tell it. Take your pick.

I’m no longer a bottleneck.

Naveen Gattu - you asked me to clone myself. 10 years later, here’re the recipe: https://sanand0.github.io/datastories/anthropic-work/

Video

Tue, 09 Dec 2025 05:36:05 +0000

When my father mentioned that Virat Kohli scored a century (again) against South Africa, I wondered how he compared to the likes of Tendulkar and Gavaskar.

I asked ChatGPT:

If you had to evaluate the quality of Indian batsmen over time, what single metric (possibly composite) would you use?

Evaluate the top Indian batsmen in history on this metric. Plot them over their active years (X-axis) along with the metric (Y-axis), labelled with the player names, on a beautiful visualization.

It picked a simple metric: Batting Average * log(Total Runs).

Claude and Gemini, too, preferred simple metrics that favored the batting average or total runs. Strike rate, relative to era, win rate impact, etc. were all excluded.

(Sadly, any metric that misses Kapil Dev feels a bit… incomplete.)

Data story: https://sanand0.github.io/datastories/indian-batting-greats/

Mapscii Rendering

Wed, 26 Nov 2025 00:00:00 +0530

I asked Claude Sonnet 4.5 on GitHub Copilot:

How does mapscii render vector tiles as text blocks on the terminal? What are the libraries it uses and how does it use them? Explain as a detailed tutorial with examples so that I can learn how to rasterize vector shapes on the terminal.

Below’s the explanation. What’s noteworthy to me is:

How it uses Braille characters to get 8 pixels per character cell (2x4 grid).
How it fills polygons using (a) triangulation and (b) getting all edge points using Bresenham’s algorithm, then (c) filling horizontal spans between edge pairs.

I’ll help you understand how mapscii renders vector tiles as text blocks on the terminal. Let me search through the repository to find the relevant code and understand the architecture. Now let me get more specific files to understand the rendering pipeline better:# How MapSCII Renders Vector Tiles as Text Blocks on the Terminal

MapSCII is a fascinating project that transforms geographic vector tiles into ASCII/Braille art on your terminal. Let me break down the complete rendering pipeline with detailed examples so you can learn how to rasterize vector shapes on the terminal.

Architecture Overview

The rendering pipeline consists of several key components:

TileSource - Fetches and manages vector tiles
Tile - Parses vector tile data (Protobuf format)
Renderer - Orchestrates the rendering process
Canvas - Provides drawing primitives (lines, polygons)
BrailleBuffer - Converts pixels to Braille/ASCII characters

Key Libraries Used

{
  "@mapbox/vector-tile": "^1.3.1", // Parse vector tile format
  "pbf": "^3.2.1", // Protobuf decoding
  "earcut": "^2.2.2", // Polygon triangulation
  "rbush": "^3.0.1", // 2D spatial indexing
  "bresenham": "0.0.4", // Line rasterization
  "simplify-js": "^1.2.4", // Polyline simplification
  "x256": "0.0.2" // Color conversion to xterm-256
}

Step-by-Step Tutorial

Step 1: Understanding Braille Characters for Pixels

Braille characters are perfect for terminal graphics because each character represents a 2×4 pixel grid:

// BrailleBuffer uses Unicode Braille patterns (U+2800 - U+28FF)
// Each Braille character has 8 dots in a 2×4 grid:
//
// ⠁ ⠂  (left column: 0x1, 0x2, 0x4, 0x40)
// ⠄ ⠈  (right column: 0x8, 0x10, 0x20, 0x80)
// ⠐ ⠠
// ⠈ ⡀

const brailleMap = [
  [0x1, 0x8],
  [0x2, 0x10],
  [0x4, 0x20],
  [0x40, 0x80],
];

Each Braille character gives you 8 pixels in just one terminal cell, effectively quadrupling your resolution!

Step 2: Creating a Braille Buffer

class BrailleBuffer {
  constructor(width, height) {
    // Map of which bits correspond to which dot positions
    this.brailleMap = [
      [0x1, 0x8],
      [0x2, 0x10],
      [0x4, 0x20],
      [0x40, 0x80],
    ];

    // Store pixel state, colors
    const size = (width * height) / 8; // Each cell stores 8 pixels
    this.pixelBuffer = Buffer.alloc(size);
    this.foregroundBuffer = Buffer.alloc(size);
    this.backgroundBuffer = Buffer.alloc(size);
  }

  // Set a single pixel at (x, y)
  setPixel(x, y, color) {
    if (x >= 0 && x < this.width && y >= 0 && y < this.height) {
      // Project x,y to buffer index
      const idx = (x >> 1) + (this.width >> 1) * (y >> 2);

      // Get the specific dot mask for this pixel
      const mask = this.brailleMap[y & 3][x & 1];

      // Set the bit
      this.pixelBuffer[idx] |= mask;
      this.foregroundBuffer[idx] = color;
    }
  }

  // Generate terminal output
  frame() {
    const output = [];
    let currentColor = null;

    for (let y = 0; y < this.height / 4; y++) {
      for (let x = 0; x < this.width / 2; x++) {
        const idx = (y * this.width) / 2 + x;

        // Add ANSI color codes when color changes
        const colorCode = this._termColor(
          this.foregroundBuffer[idx],
          this.backgroundBuffer[idx],
        );
        if (currentColor !== colorCode) {
          output.push(currentColor = colorCode);
        }

        // Convert pixel bits to Braille character
        const brailleChar = String.fromCharCode(0x2800 + this.pixelBuffer[idx]);
        output.push(brailleChar);
      }
      output.push("\n");
    }

    return output.join("");
  }

  _termColor(foreground, background) {
    if (foreground && background) {
      return `\x1B[38;5;${foreground};48;5;${background}m`;
    } else if (foreground) {
      return `\x1B[49;38;5;${foreground}m`;
    }
    return "\x1B[39;49m"; // Reset
  }
}

Step 3: Drawing Lines with Bresenham’s Algorithm

const bresenham = require("bresenham");

class Canvas {
  constructor(width, height) {
    this.buffer = new BrailleBuffer(width, height);
  }

  // Draw a line from point A to point B
  line(from, to, color, width = 1) {
    if (width === 1) {
      // Simple bresenham for single-pixel width
      bresenham(from.x, from.y, to.x, to.y, (x, y) => {
        this.buffer.setPixel(x, y, color);
      });
    } else {
      // Thick line using Bresenham with width
      this._thickLine(from.x, from.y, to.x, to.y, width, color);
    }
  }

  // Draw a polyline (e.g., roads, rivers)
  polyline(points, color, width = 1) {
    for (let i = 1; i < points.length; i++) {
      this.line(points[i - 1], points[i], color, width);
    }
  }
}

Step 4: Drawing Filled Polygons with Earcut

For filled areas (buildings, water bodies), MapSCII uses polygon triangulation:

const earcut = require("earcut");

class Canvas {
  polygon(rings, color) {
    // Convert rings to flat array of vertices
    const vertices = [];
    const holes = [];

    for (const ring of rings) {
      if (vertices.length) {
        holes.push(vertices.length / 2); // Mark hole start
      }
      for (const point of ring) {
        vertices.push(point.x);
        vertices.push(point.y);
      }
    }

    // Triangulate the polygon
    const triangles = earcut(vertices, holes);

    // Draw each triangle
    for (let i = 0; i < triangles.length; i += 3) {
      const pa = [vertices[triangles[i] * 2], vertices[triangles[i] * 2 + 1]];
      const pb = [
        vertices[triangles[i + 1] * 2],
        vertices[triangles[i + 1] * 2 + 1],
      ];
      const pc = [
        vertices[triangles[i + 2] * 2],
        vertices[triangles[i + 2] * 2 + 1],
      ];

      this._filledTriangle(pa, pb, pc, color);
    }
  }

  _filledTriangle(pointA, pointB, pointC, color) {
    // Get edges using Bresenham
    const a = bresenham(pointB[0], pointB[1], pointC[0], pointC[1]);
    const b = bresenham(pointA[0], pointA[1], pointC[0], pointC[1]);
    const c = bresenham(pointA[0], pointA[1], pointB[0], pointB[1]);

    // Combine and sort all edge points by Y, then X
    const points = a
      .concat(b)
      .concat(c)
      .filter((p) => p.y >= 0 && p.y < this.height)
      .sort((a, b) => (a.y === b.y ? a.x - b.x : a.y - b.y));

    // Fill horizontal spans between edge pairs
    for (let i = 0; i < points.length - 1; i++) {
      const point = points[i];
      const next = points[i + 1];

      if (point.y === next.y) {
        // Draw horizontal line
        for (let x = point.x; x <= next.x; x++) {
          this.buffer.setPixel(x, point.y, color);
        }
      } else {
        this.buffer.setPixel(point.x, point.y, color);
      }
    }
  }
}

Step 5: Processing Vector Tiles

const VectorTile = require("@mapbox/vector-tile").VectorTile;
const Protobuf = require("pbf");
const RBush = require("rbush");
const zlib = require("zlib");

class Tile {
  async load(buffer) {
    // Decompress if gzipped
    if (this._isGzipped(buffer)) {
      buffer = await new Promise((resolve, reject) => {
        zlib.gunzip(buffer, (err, data) => {
          err ? reject(err) : resolve(data);
        });
      });
    }

    // Parse Protobuf
    this.tile = new VectorTile(new Protobuf(buffer));

    // Process each layer
    const layers = {};
    for (const name in this.tile.layers) {
      const layer = this.tile.layers[name];
      const nodes = [];

      for (let i = 0; i < layer.length; i++) {
        const feature = layer.feature(i);
        const geometries = feature.loadGeometry();

        // Get style for this feature
        const style = this.styler.getStyleFor(name, feature);
        if (!style) continue;

        // Convert geometries to nodes with boundaries
        for (const points of geometries) {
          nodes.push(
            this._addBoundaries({
              layer: name,
              style,
              points,
              color: this._getColor(style),
            }),
          );
        }
      }

      // Create spatial index for efficient querying
      const tree = new RBush(18);
      tree.load(nodes);

      layers[name] = {
        extent: layer.extent,
        tree,
      };
    }

    return layers;
  }
}

Step 6: The Complete Rendering Pipeline

class Renderer {
  async draw(center, zoom) {
    this.canvas.clear();

    // 1. Calculate visible tiles
    const tiles = this._visibleTiles(center, zoom);

    // 2.  Fetch all tiles in parallel
    await Promise.all(
      tiles.map(async (tile) => {
        tile.data = await this.tileSource.getTile(
          tile.xyz.z,
          tile.xyz.x,
          tile.xyz.y,
        );

        // 3. Query spatial index for visible features
        const scale = tile.data.layers[layerId].extent / tileSize;
        tile.layers[layerId].features = tile.data.layers[layerId].tree.search({
          minX: -tile.position.x * scale,
          minY: -tile.position.y * scale,
          maxX: (this.width - tile.position.x) * scale,
          maxY: (this.height - tile.position.y) * scale,
        });
      }),
    );

    // 4. Draw features in correct order (background to foreground)
    const drawOrder = ["water", "landuse", "building", "road", "poi_label"];
    for (const layerId of drawOrder) {
      for (const tile of tiles) {
        for (const feature of tile.layers[layerId].features) {
          this._drawFeature(tile, feature, scale);
        }
      }
    }

    // 5. Generate terminal output
    return this.canvas.frame();
  }

  _drawFeature(tile, feature, scale) {
    // Transform coordinates from tile space to screen space
    const points = feature.points.map((p) => ({
      x: Math.floor(tile.position.x + p.x / scale),
      y: Math.floor(tile.position.y + p.y / scale),
    }));

    // Draw based on geometry type
    switch (feature.style.type) {
      case "line":
        this.canvas.polyline(
          points,
          feature.color,
          feature.style.paint["line-width"],
        );
        break;
      case "fill":
        this.canvas.polygon([points], feature.color);
        break;
      case "symbol":
        this.canvas.text(
          feature.label,
          points[0].x,
          points[0].y,
          feature.color,
        );
        break;
    }
  }
}

Step 7: Coordinate Transformations

const utils = {
  // Convert lat/lon to tile coordinates at zoom level
  ll2tile(lon, lat, zoom) {
    const n = Math.pow(2, zoom);
    return {
      x: ((lon + 180) / 360) * n,
      y: ((1
        - Math.log(
            Math.tan((lat * Math.PI) / 180)
              + 1 / Math.cos((lat * Math.PI) / 180),
          ) / Math.PI) / 2) * n,
    };
  },

  // Convert tile coordinates back to lat/lon
  tile2ll(x, y, zoom) {
    const n = Math.pow(2, zoom);
    return {
      lon: (x / n) * 360 - 180,
      lat: (Math.atan(Math.sinh(Math.PI * (1 - (2 * y) / n))) * 180) / Math.PI,
    };
  },

  // Get tile size in pixels at fractional zoom
  tilesizeAtZoom(zoom) {
    return Math.pow(2, zoom - Math.floor(zoom)) * 256;
  },
};

Complete Example: Drawing a Simple Map

const Canvas = require("./Canvas");
const x256 = require("x256");

// Create a 160x64 pixel canvas (80x16 terminal cells in Braille mode)
const canvas = new Canvas(160, 64);

// Define some colors (xterm-256 color codes)
const BLUE = x256([0, 0, 255]);
const GREEN = x256([0, 200, 0]);
const GRAY = x256([128, 128, 128]);

// Draw a river (polyline)
const riverPoints = [
  { x: 20, y: 50 },
  { x: 40, y: 45 },
  { x: 60, y: 40 },
  { x: 80, y: 35 },
  { x: 100, y: 30 },
];
canvas.polyline(riverPoints, BLUE, 3);

// Draw a building (polygon)
const buildingRing = [
  { x: 70, y: 20 },
  { x: 90, y: 20 },
  { x: 90, y: 40 },
  { x: 70, y: 40 },
];
canvas.polygon([buildingRing], GRAY);

// Draw a road (polyline)
const roadPoints = [
  { x: 0, y: 25 },
  { x: 160, y: 25 },
];
canvas.polyline(roadPoints, GRAY, 2);

// Draw a label
canvas.text("Town Hall", 80, 30, GRAY);

// Output to terminal
process.stdout.write(canvas.frame());

Performance Optimizations

MapSCII uses several clever optimizations:

RBush Spatial Index: Only processes features visible in the viewport
Polyline Simplification: Uses simplify-js to reduce point counts
Tile Padding: Renders slightly beyond viewport to avoid edge artifacts
Draw Order Optimization: Different layer orders for different zoom levels
Color Caching: Avoids repeated color conversions

Key Takeaways

To rasterize vector shapes on the terminal:

Use Braille characters for 4x resolution boost (2×4 pixels per cell)
Implement a pixel buffer that maps coordinates to Braille dot positions
Use Bresenham’s algorithm for line rasterization
Use Earcut for polygon triangulation and scanline filling
Leverage xterm-256 colors with ANSI escape codes
Transform coordinates from geographic space to screen space
Use spatial indexing (RBush) for efficient viewport queries

The complete rendering pipeline is: Vector Tiles → Parse Protobuf → Query Spatial Index → Transform Coordinates → Rasterize to Pixels → Convert to Braille → Output ANSI Codes

You can explore more implementation details in the rastapasta/mapscii repository.

When to choose AI over humans

Tue, 28 Oct 2025 04:37:14 +0000

I charted the OpenAI GDPVal paper with industry compensation as the size and AI augmentation as color. Big green areas are we’re paying people where AI does better.

Click here to see the interactive visualization.

Clicking to see some actual tasks compared.

I use this to check whom to ask advice: AI or professional.

AI beats Personal Financial Advisors ~64% of the time. So I invested half my money using ChatGPT’s recommendation. (UTI Nifty 50, if you’re curious.)

Accountants beat AI 76% of the time. So my tax returns are still filed by Ventura Pranas.

AI beats Government - Administrative Services Managers 62% of the time. I haven’t figured out how to bypass them yet. Nor customer service representatives.

Overall, AI beats most managers and clerks, not industrial engineers and pharmacists.

Here’s my current thought where I wouldn’t hire AI if a high portion of their work

Has legal liability (e.g. pharmacist/judge vs shop attendant/lawyer)
Is subjective (e.g. perfumer/auction appraiser vs lab chemist/insurance appraiser)
Needs rapid contextual decisions (e.g. detective/fireman/ER vs parking enforcer)

But this apart, if they charged half, would their demand double? If so, even with AI, they’ll have more demand.

Sun, 29 Jun 2025 10:25:14 +0000

We created data visualizations just using LLMs at my VizChitra workshop yesterday.

Titled Prompt to Plot, it covered:

Finding a dataset
Ideating what to do with it
Analyzing the data
Visualizing the data
Publishing it on GitHub

… using only LLM tools like #ChatGPT, #Claude, #Jules, #Codex, etc. with zero manual coding, analysis, or story writing.

Here’re 6 stories completed during the 3-hour workshop:

Spotify Data Stories: https://rishabhmakes.github.io/llm-dataviz/
The Price of Perfection: https://coffee-reviews.prayashm.com/
The Anatomy of Unrest: https://story-b0f1c.web.app/
The Page Turner’s Paradox: https://devanshikat.github.io/BooksVis/
Do Readers Love Long Books? https://nchandrasekharr.github.io/booksviz/
Books Viz: https://rasagy.in/books-viz/

The material is online. Try it!

Slides: https://sanand0.github.io/talks/2025-06-28-prompt-to-plot/

Sun, 29 Jun 2025 04:20:23 +0000

My VizChitra talk on Data Design by Dialog was on LLMs helping in every stage of data storytelling.

Main takeaways:

After open data, LLMs may the single biggest act of data democratization. https://youtu.be/hPH5_ulHtno?t=01m24s
LLMs can help in every step of the (data) value chain. https://youtu.be/hPH5_ulHtno?t=00m47s
LLMs are bad with numbers. Have them write code instead. https://youtu.be/hPH5_ulHtno?t=06m33s
Don’t confuse it. Just ask it again. https://youtu.be/hPH5_ulHtno?t=05m30s
If it doesn’t work, throw it away and redo it. https://youtu.be/hPH5_ulHtno?t=20m02s
Keep an impossibility list. Revisit it whenever a new model drops. https://youtu.be/hPH5_ulHtno?t=20m02s
Never ask for just one output from an LLM. Ask for a dozen. https://youtu.be/hPH5_ulHtno?t=22m20s
Our imagination is the limit. https://youtu.be/hPH5_ulHtno?t=26m35s
Two years ago, they were like grade 8 students. Today, a postgraduate. https://youtu.be/hPH5_ulHtno?t=00m47s
Do as little as possible. Just wait. Models will catch up. https://youtu.be/hPH5_ulHtno?t=31m45s

Funny bits:

This is how it’s done. How else would we do it? https://youtu.be/hPH5_ulHtno?t=04m31s
Some people call biases domain expertise. https://youtu.be/hPH5_ulHtno?t=22m50s
I don’t like work. I like playing Bubbles. So, have it do the work. https://youtu.be/hPH5_ulHtno?t=23m08s
More metrics, more quirky! https://youtu.be/hPH5_ulHtno?t=26m20s
Amuse me! https://youtu.be/hPH5_ulHtno?t=21m37s

Thu, 05 Jun 2025 05:36:05 +0000

I lost 22 kg in 22 weeks.

How? Skipped lunch, no snacking. (That’s all.)

Why? Cholesterol.

When? Since 1 Jan 2025. I plan to continue.

How far? At 64 kg, I’m at 22 BMI. I’ll aim for 60 kg.

Is fasting 12 hours OK? Ankor Rai shared Dr. Mindy Pelz’s chart that fasting benefits truly kick in after 36 hours. Long way for me to go.

No exercise? Exercise is great for fitness & happiness. Not weight loss. Read John Walker’s The Hacker’s Diet.

No LLMs stuff this post? Of course! I vibe coded the data extraction, analysis and visualization with Claude Code for my VizChitra talk:

Data viz: https://sanand0.github.io/datastories/weight-2025-06/
Prompts: https://github.com/sanand0/datastories/tree/main/weight-2025-06

How to Create a Data Visualization Without Coding

Sun, 27 Apr 2025 09:45:21 +0000

After seeing David McCandless’ post “Which country is across the ocean?” I was curious which country you would reach if you tunneled below in a straight line (the antipode).

This is a popular visualization, but I wanted to see if I could get the newer OpenAI models to create the visual without me 𝗿𝘂𝗻𝗻𝗶𝗻𝗴 any code (i.e. I just want the answer.) After a couple of iterations, O3 did a great job with this prompt:

𝙱𝚞𝚒𝚕𝚍 𝚊 _𝚜𝚒𝚗𝚐𝚕𝚎_ 𝙶𝚎𝚘𝙹𝚂𝙾𝙽 (𝙴𝙿𝚂𝙶:𝟺𝟹𝟸𝟼) 𝚝𝚑𝚊𝚝 𝚜𝚑𝚘𝚠𝚜, 𝚏𝚘𝚛 𝚎𝚊𝚌𝚑 𝚌𝚘𝚞𝚗𝚝𝚛𝚢, 𝚘𝚗𝚕𝚢 𝚝𝚑𝚎 𝚙𝚊𝚛𝚝𝚜 𝚘𝚏 𝚒𝚝𝚜 𝚊𝚗𝚝𝚒𝚙𝚘𝚍𝚎 𝚝𝚑𝚊𝚝 𝚕𝚒𝚎 𝚘𝚟𝚎𝚛 𝚘𝚌𝚎𝚊𝚗. 𝙲𝚊𝚛𝚎𝚏𝚞𝚕𝚕𝚢 𝚑𝚊𝚗𝚍𝚕𝚎 𝚌𝚘𝚞𝚗𝚝𝚛𝚒𝚎𝚜 𝚝𝚑𝚊𝚝 𝚜𝚝𝚛𝚊𝚍𝚍𝚕𝚎 𝚝𝚑𝚎 𝚙𝚛𝚒𝚖𝚎 𝚖𝚎𝚛𝚒𝚍𝚒𝚊𝚗 - 𝚄𝙺, 𝙵𝚛𝚊𝚗𝚌𝚎, 𝙰𝚕𝚐𝚎𝚛𝚒𝚊, 𝚎𝚝𝚌.

Here is the output and here is the ChatGPT conversation that generated it.

I learnt a few things:

Ask for the output, not the code. Models like O3 and O4 Mini can run code while thinking. Let’s stop asking for code to run. Just ask for the output directly. Let it figure out how.
Edge cases are everywhere. I had a problem with UK, France, Algeria, etc. straddling the prime meridian. If all goes well, you get AI-speed results. But it never does, and fixing it takes an expert and human-speed results. Programmers under-estimate edge cases, so compensate for this.

If you want to run this yourself, the code is at https://github.com/sanand0/antipodes

How to Use the New O4 Mini for Data Visualization

Sun, 20 Apr 2025 09:44:27 +0000

O3/O4 Mini are starting to replace Excel (or Tableau/Power BI) for quick analysis and visualizations. At least for me.

I normally open Excel when I need a fast chart or pivot. For instance, we track outages of our semi‑internal server, LLM Foundry.

To grab the data I ran one line in the browser console:

$$(".lh-base").map(d => d.textContent.trim()).filter(d => d.includes("From"));

This produced lines like:

Apr 20, 2025 03:11:27 PM +08 to Apr 20, 2025 03:27:12 PM +08 (15 mins 45 secs)
Apr 19, 2025 10:03:15 PM +08 to Apr 19, 2025 10:05:45 PM +08 (2 mins 30 secs)
Apr 19, 2025 09:47:13 PM +08 to Apr 19, 2025 09:49:45 PM +08 (2 mins 32 secs)
Apr 19, 2025 08:49:00 PM +08 to Apr 19, 2025 08:51:51 PM +08 (2 mins 51 secs)
Apr 19, 2025 08:13:02 PM +08 to Apr 19, 2025 08:15:35 PM +08 (2 mins 33 secs)
...

Then I told O4-Mini-High:

Here are downtimes for llmfoundry.straive.com. Convert this to CSV and allow me to download it. Also, draw the downtimes on a grid, rows=hour of day, columns=date, cell contains 1 circle per outage in that time period, size of each circle is based on the duration of the outage.

Apr 20, 2025 03:11:27 PM +08 to Apr 20, 2025 03:27:12 PM +08 (15 mins 45 secs) Apr 19, 2025 10:03:15 PM +08 to Apr 19, 2025 10:05:45 PM +08 (2 mins 30 secs) Apr 19, 2025 09:47:13 PM +08 to Apr 19, 2025 09:49:45 PM +08 (2 mins 32 secs) … (rest of the data - about 50 rows)

Here’s the power of what a model like O4 Mini High can do.

It can reason. So, it planned an approach. (Convert to CSV, transform into date and hour. create a grid-based plot, use a pandas DataFrame, save it to a CSV, etc.)
It can code. It is pretty good at coding, and this is not too hard a problem, so it got the code right in one shot.
I can run code. This is a powerful step. It executed the code and produced the visualization above.

All of this took less than one minute.

I did not look at the code. I just focused on the picture and suggested changes.

This draws crosses, not circles, for each hour. Also, if there are multiple outages in an hour, I want multiple circles.

Here’s the output that took less than 10 seconds:

Next iteration:

Make the circles red with the same level of transparency. Set the title to “LLM Foundry Downtime (SGT)”. Instead of jittering the circle, let the Y position be the middle of the outage time.

Next iteration:

Change the red to a milder shade. Set alpha to 0.5 but add a stroke with alpha 0.9. Format the dates like “Sun 20 Apr”, etc.

That’s it! I never even looked at the code. The whole loop took 3 minutes - far faster than I could manage, though I’m good at code and data visualization!

More importantly, the model frees me to focus on the real problem, which is why is the downtime high?

ImageGen 3 is the top image model now

Mon, 10 Mar 2025 04:03:42 +0000

Gemini’s ImageGen 3 is rapidly evolving into a very powerful image editing model. In my opinion, it’s the best mainstream image generation model.

Ever since it was released, it’s been the most realistic model I’ve used. I’ve been using it to imagine characters and scenes from The Way of Kings. For example, when I wanted to visualize Helaran’s first appearance, I just quoted the description:

Draw this. Galloping directly toward them was a massive black horse bearing a rider in gleaming armor that seemed to radiate light. That armor was seamless—no chain underneath, just smaller plates, incredibly intricate. The figure wore an unornamented full helm, and the plate was gilded. He carried a massive sword in one hand, fully as long as a man was tall. It wasn’t a simple, straight sword—it was curved, and the side that wasn’t sharp was ridged, like flowing waves. Etchings covered its length. It was beautiful. Like a work of art. Cenn had never seen a Shardbearer, but he knew immediately what this was. How could he ever have mistaken a simple armored lighteyes for one of these majestic creatures?

And it generated this:

Or, to visualize Highprince Roion:

Draw this. Highprince Roion stood in front of one of the maps, hands clasped behind his back, his numerous attendants clogging the other side of the gallery. Roion was a tall, light-skinned man with a dark, well-trimmed beard. He was thinning on top. Like most of the others, he wore a short, open-fronted jacket, exposing the shirt underneath. Its red fabric poked out above the jacket’s collar.

Here’s the first appearance of Kaladin:

Draw this. A man walked up through the ranks, carrying a shortspear that had two leather knife sheaths strapped to the haft. The newcomer was a young man—perhaps four years older than Cenn’s fifteen—but he was taller by several fingers than even Dallet. He wore the common leathers of a spearman, but under them was a pair of dark trousers. That wasn’t supposed to be allowed. His black Alethi hair was shoulder-length and wavy, his eyes a dark brown. He also had knots of white cord on the shoulders of his jerkin, marking him as a squadleader.

The images are stunning in quality, reproduce the prompt quite faithfully, and cost 2-4 cents each (via the API.)

But this is just the begining of power of ImageGen 3. For those with access, you can edit existing images, e.g.

Inpainting: add stuff to images
Outpainting: extend an image, zooming out
Product editing: replace the background with something else (actually, this is powerful for lots of things beyond products)
Styling: change the style of an image (e.g. photo to comic)
Changing the context: draw this dog but in a different setting
… and more

A fair bit of this can be done by selecting a region (masking) or mask-free.

I’m really looking forward to this.