Thirteen projects in three days

They have almost nothing in common. Different data sources, math, rendering, architecture, visualization. One reads tax records. One trains a neural network in your browser while you click. One is a card game. One generates its own numbers from a seed and uses no dataset at all.

The range is what I am trying to accomplish/display. Coding agents can do incredible stuff. But their work is typically very easy to identify as a "Claude Code" or "Codex" project. Getting thirteen genuinely different projects from the same model requires specificity and detailed instructions: what the data actually supports, what method fits the question, what it should look like, fonts, colors, interactions, tools, etc.

The harness was built over months before this run. That is the part that made three days possible.

Work starts with brainstorming, which ensures the model and I are on the exact same page about the project.  Many of the details don’t exist at the inception of an idea, so the model guides me through them while offering suggestions.  It also thinks through future edge cases and potential “gotchas” before they become problems. This is the most time-consuming part of every project, on the human side.  Planning and validation are where I add the most value, and spend the most time.  Then the model writes a spec, I approve it, and it breaks the work into tickets that are executed in order.  The model decides which tasks can run in parallel using subagents and which require my involvement versus which it can complete AFK (away from keyboard).

Projects never start as code.  Every ticket defines the expected outcome, the constraints, and a definition of done or a '/goal'.  That definition becomes the standard every implementation is measured against.  Procedures I repeat across projects become skills: reusable instructions an agent loads when a situation comes up.  They define how we approach the task, which tools to use, and what finished looks like.  Hooks block commands I don’t want executed.  Approval gates sit in front of anything destructive.

The core loop is adversarial.  One agent builds while another evaluates the result against a concrete rubric.  Ask a model whether its own work is good and it will confidently tell you yes, usually with a convincing explanation.  That answer is worthless.  The reviewer is never the builder, and for visual work it evaluates rendered screenshots instead of source code through a Google Chrome MCP connector.  That separation is responsible for much of the quality across these projects.

Giving a model eyes helps with:

The value of each increases dramatically when one agent derives a solution and another argues against it.

Most of these projects will likely look very different soon. I've built the simplest working version of each.

Namesake is built on every US Social Security birth record going back to 1880. You type a name and watch its whole life story rise, crest, and fall. The charts are plain SVG, drawn directly rather than through a charting library, which is what makes the small sparkline chips next to each name possible. It is a warm paper-colored page with a serif display face, deliberately closer to a printed reference book than a dashboard. Built with Astro. Will be adding cool video and interactive elements in the future.

The Real Price of Everything, or nine things, uses Bureau of Labor Statistics CPI data from 1980 to 2024. Strip out inflation and compare things in real terms rather than nominal dollars. Nine familiar items then diverge on one axis. In real terms televisions come out down 100 percent and clothing down 62, while rent is up 36, childcare up 55, healthcare up 98, and education up a ridiculous 248. It is built as scrollytelling, so the divergence happens as you move down the page.

Where America Moves is built on IRS Statistics of Income county-to-county migration records, which track where households filed from this year against where they filed the year before. It renders as a D3 chord diagram, a dense directed ring where every ribbon is a real flow between two metros, paired with a map. Across the largest US metros that is about 1.6 million people moving in a single year, with twelve metros gaining on net and eighteen losing. Dallas is up 39,109. New York is down 174,207. Or filter per capita. The design is editorial and restrained, cream and ink with a serif, so that the ring is the only loud thing on the page.

Climate Fingerprint uses ERA5 climate normals, thirty years of daily temperature and rainfall, and draws each city's typical year as a single radial poster. Thirty cities sit on one shared scale so they can honestly be compared side by side, and typing any other city computes its poster in your browser. Rainfall runs on a square root scale so wet cities do not flatten everything else. The output is SVG, the palette is spectral, and the page is dark specifically so the color has something to glow against. Fairbanks next to Singapore is the argument for building it this way.

Redraft uses nflverse play-by-play data covering every NFL season from 1999 to 2025, scored PPR. It is a fantasy football card game built on one idea: the mistake is not picking the wrong player, it is picking the wrong season. Four player/seasons a pick, seven roster spots, and a season you spend is gone from every other pick on the board. No accounts, no login, no server. Visually it is the furthest from everything else: near black, gold, stadium lighting, a heavy display serif.

Meaning Map places 893 US occupations by what the work actually involves rather than by the industry that employs it. The method is what makes this one fun. It takes O*NET task descriptions, runs them through a bge-small-en-v1.5 text embedding model, and projects the result down to two dimensions with UMAP, then bakes the similarity lookup at build time so the page ships as static files and the browser does no heavy computation. Wage and employment figures come from BLS OEWS. Jobs that sit near each other genuinely do similar work, and you can click any point to see its nearest neighbors. Ten occupation families are drawn as soft hulls over a light ground, with the labels set small so the point cloud carries the page.

Sensor Trust is the one that runs on a schedule rather than sitting still. A Python job pulls the OpenAQ feed daily and scores every US PM2.5 sensor it redistributes on a single question: is this feed reporting the way it should? That is a data-health question, not an air-quality one, and it is not a calibration judgment either. It currently tracks 5,173 deduplicated physical sites. 3,558 of those are still reporting and get scored; the other 1,615 are dark. Of the ones reporting, 45.9 percent fail at least one data-quality check. Python and cron on the ingest side, Astro on the publishing side.

Why Do They is built on data I scraped at a single moment rather than a published dataset: 4,331 Google autocomplete suggestions captured on July 24, using symmetric stems for men and for women so the two sides are actually comparable. It records what the search box offers to finish for you, which is not a poll, and it does not get presented as one. The capture date is published on the page because a scrape is only true for the moment it was taken. The current version renders as two radial blooms, spectral color on a dark ground, with the real questions readable beside them.

The next version of it is an experiment I should be upfront about. I am trying to replicate Nadieh Bremer's Why do cats and dogs...? study, as closely as I can, for men and women instead of pets. Her study, her structure, her visual language, fully credited, with my Google data underneath. I am not doing that because I want to pass it off as my own idea. I am doing it because it is one of the best tests I can think of. It's a great use case to test wether my setup is actually capable of that level of craft, and it's piece of work I admire. This one's not done yet, but so far it is 'passing with flying colors'.

Cascade implements three models and runs them live in front of you: a forest fire on a site percolation lattice, a Bak-Tang-Wiesenfeld sandpile, and a cascading power grid failure where load redistributes until the system collapses. The percolation threshold lands near 0.59 and the sandpile avalanche exponent near 1.3, both known values, which means the implementation has something real to be checked against. It runs on canvas, and the chart is built from your own runs rather than replayed from a recording. 110 tests. The page is near black with monospace labels, closer to an instrument than an article. The power grid is my favorite.

By Example is a neural network trained in your browser while you click. Two inputs, eight hidden units, one output, a multilayer perceptron written by hand rather than pulled from a library, running on canvas. You place labeled points and watch the decision boundary bend to accommodate them. No server, no API calls, no cost per visitor. It is the shortest possible explanation of what supervised learning actually does, and it is dark with a warm and cool split field so the boundary is the only thing you look at.

Statistical Illusions carries no dataset either. It generates its numbers in the browser from a seed, which means every illusion is reproducible and can be honestly described as fair. Four of them are playable: the garden of forking paths, Simpson's paradox, the base rate problem that makes a highly accurate test nearly useless for a rare condition, and survivorship bias built on Abraham Wald's returning bombers. Every number is shown to you in full before you act, and you still walk into it. That is the argument. Nobody has to lie for a number to mislead you. It is set as a light editorial page, closer to a printed essay than the others.

A fantasy football draft advisor, local first and free, that runs during a live draft. Tier zero works. A whole-pipeline review caught that its ranker ordered players correctly within a position and incorrectly across positions, which no individual code review had flagged, and that repair is outstanding. I wrote about this project last week. Everything is CLI at the moment but it will be a robust Streamlit App.

And 2 other unnamed projects, comparing many different UI and Data Viz strategies and skills, to show visually what the skills do.

Across thirteen projects many methods were used to create the projects you just looked at: text embeddings and dimensionality reduction, a hand-written neural network, site percolation, self-organized criticality, cascading failure simulation, chord layout, scrollytelling, radial SVG poster generation, GPT-2 image generation, seeded pseudo-random generation, inflation adjustment, deduplication and data-health scoring against a live API, and a deterministic card game engine... plus many more. I can't keep up with them all.

Data sources: Social Security Administration, Bureau of Labor Statistics CPI and OEWS, IRS Statistics of Income, O*NET, ERA5 climate normals, OpenAQ, nflverse, Google autocomplete, and three projects that use no external data whatsoever.

Architecturally they split three ways. One is a scheduled pipeline that runs every day. Several precompute everything at build time so the page ships as static files. Several compute entirely in your browser at the moment you interact with them. Choosing which of those a project should be determines whether it is cheap and fast or slow and fragile, and it is the decision a coding agent gets wrong most often when you let it decide alone.

None of these thirteen used a pre-existing design system. They used the skills I already had, and the visual direction on each one was argued out project by project. The skills allow the projects to be dynamic.

What I am doing now is running structured tests on what coding agents can actually produce for data visualization and interface design. Not accepting the first output and not guessing at it. Generating the full range of options for a given problem so I can put them side by side and judge, then working out which references, instructions, and constraints reliably produce the good ones.

Visual Cinnamon, Nadieh Bremer's work, is the one I love. It is the most beautiful data visualization being made and it is not close. Spectral color, radial form. If I could make things that look like that I would be happy... And it looks like I can.

Truth and Beauty, Moritz Stefaner's work, is the restraint. Real numbers, a source line, nothing on the page that is not doing a job. It is the correction to my instinct to add one more thing.

Distill is the easy read. Genuinely difficult material laid out so you can actually follow it, with the explanation and the graphic working together instead of competing.

The hard part is that those three do not simply stack. Beauty and restraint are polar opposites... at least they are in this world. Getting all three at once is the actual problem I am working on, and I do not have it solved.

My motivation for all of this is pretty simple: I'm trying to automate myself out of a job.

This is what I do for a living. I take messy data, figure out what it actually means, validate it, and turn it into something people can understand and act on. Sometimes I do data science. I'm finishing a master's in data science, but I'm not a PhD data scientist. Sometimes I build things, but I'm not a software developer. Sometimes I do database administration, but I'm not a DBA.

I'm a data guy who happens to know a little about a lot of things.

If AI eventually replaces parts of my job, I'd rather be the person who figured out how to replace myself than have it done by a contractor I've never met. That's the honest motivation behind everything I'm building.

The future is uncertain for everyone. I'm not pretending to know exactly where it's headed. I'm just trying to keep up, document what I learn, and build systems that make me better at what I do today.

Maybe that's the best introduction to my site. Speaking of which...

My current site is a space theme, and I am getting rid of it.

I got carried away. I threw in as many interactive and WebGL elements as I could fit, and the result is slow, overwhelming, and hard to read. That should not be the goal of any site. I built it to prove I could, which is a bad reason to build anything a stranger has to use.

The clearest way to see the problem is to imagine a recruiter opening it. There is no version of that where they think this is impressive. It is much more likely to be: what is this, why is it so slow, what is a second brain, and why is there a floating three dimensional render of his head following my cursor around the page. Creepy. Let us stay away from this guy.

I would like to prevent that reaction.

So the new one will be simple and mostly white. The complexity belongs inside the projects and the apps, where someone has already chosen to engage with a thing and the load is the point. It does not belong on the page where somebody is deciding in four seconds whether I am worth taking seriously. I am hoping to keep the head that follows the cursor and the brain globe somewhere, possibly small enough that nobody notices, possibly buried a few levels down where only someone who went looking will find them.

The other reason for the rebuild is that I want somewhere to put work that is not an email. I will probably keep this newsletter going, but I would like to publish something every few days, and nobody wants that many alerts in their inbox. What I actually need is a place on my own site to log the work as it happens, in whatever format fits it that day, and to keep the newsletter for the things worth interrupting someone over.

What already carries over is smaller and older than any of these projects. The thing that writes the code cannot be the thing that decides whether the code is right, and the thing that checks the code is also a thing that can be wrong. Whatever is still wrong in these is whatever nothing has checked yet.

Thanks for reading 🙏

Most of them are at dustincoledata.com/projects

Enjoy.

🗞️ Newsletter: dustincoledata.beehiiv.com

🌐 Site: dustincoledata.com

-Dustin