Most diagram types share more structure than their APIs show. A bar chart and pie chart obviously use the same data with different displays - Mike Bostock's D3 taught us to think think in terms of the data and transforming it. The potential unification goes deeper. When you see that a stream graph is a constrained Sankey diagram (flows connecting the same categories across time), new possibilities emerge. Your stream graph can now have exceptional flows that break the normal pattern.
Sharing such structure means components compose naturally. One ribbon implementation works across multiple layouts. End shapes work across contexts. It means less code does more. I don't maintain separate code for ribbons, bars, and streams. The pieces fit together because they're built on the same model.
AI has made rapid exploration of such ideas viable. I can test ideas out to identify what works, and abandon dead ends without a huge investment of time. This velocity lets me pursue the larger goal: building a toolkit where diagram types morph smoothly into each other - because they are built on the same foundation.
My process centers on AI-constructed spike solutions - small demos to test ideas. I iterate on these demos, then I work them up to be composable pieces. Some become tools you can use directly from this website, like the mind-map tool. The small demos become building blocks that combine like lego to make domain-specific web apps and custom interactive diagrams.
The spike solutions on this site are raw explorations with rough edges, not polished deliverables, but they're how the work progresses. They show the AI collaboration in practice.
Take the git repository visualization I'm working on. Because I'd unified the underlying models, I could show repository changes over time as a stream graph, but also display exceptional flows when files migrate between directories. The unification made a new display possible that was actually useful. I'd used AI to help code the unified version.
Then, to build the git viewer, I needed data from git plumbing commands I don't normally use. AI wrote the extraction script quickly, working on the first try, without me diving into documentation. The cost of exploring the idea dropped enough that a direction I wouldn't have bothered investigating, yet another git visualization tool, became viable.
Another example: visualizing data flow in AI systems using tilted matrices. Think of old distance-between-cities tables, but now the tilt makes flow direction intuitive. In the matrix multiplication data flows in by row and out by column, inputs and outputs at 90 degrees rather than following the standard matrix multiplication conventions. Plotting a table at 45 degrees has just enough friction that without AI making the prototype quick and easy, I probably wouldn't have tried the tilted matrices.
The tilted approach also extends more nicely to chains of matrix multiplies. Visually it also suggests that it would be easy to handle matrices with values close to the main diagonal. The trimmed matrices pack nicely. This suggests an algorithmic opportunity. If large values cluster near the diagonals, maybe smaller values far from the diagonal can be dropped? The matrix 'diamonds' become narrow vertical strips. This is somewhere between a convolution and a matrix multiply. There's a potential path from O(n²) to O(n·d) complexity if such matrix quantization works out. The visual presentation suggests the sparsification strategy.
You can see the tilted matrix approach in the morphing graphs spike solution . This is what happens when exploration is cheap: visualization suggests algorithmic insights you might not otherwise have seen.
The mind mapper tool shows the design philosophy in practice. Drop in a bulleted list, get an auto-layout mind map from the implied tree structure. Drag nodes to customize. The text updates with coordinates.
This combines graphviz-like automatic layout with WYSIWYG editing. You get data-driven layout without being locked into pure automation, and you get customization without pure manual work. The more powerful widget emerged from putting different user interface elements on the same footing. Combining an automated layout and a manually editted layout in one widget ultimately means less code to maintain and a better experience for users of it.
I experimented with using tests to help AI work more autonomously - the idea being it could iterate longer without guidance if tests provided feedback. AI is also good at repetitive tasks such as writing tests, so I expected this step to go smoothly. For Python utility code, this worked well. For JavaScript UI code, it didn't. The tests became another thing to maintain without enabling longer AI runs. The actual visual output was always the real test.
For visual testing, the AI had to install Playwright, which it struggled with. When it had this done, it couldn't really see the significance of changes even with the screenshots. It would declare an outcome good based on the fact that it got any image at all. It was much better looking at text diffs than doing visual comparisons.
For solo exploratory UI work, I found automated tests added maintenance burden without enough benefit. Tests have real value in team settings with multiple people on the same code, but that's not my situation.
There's a dichotomy in JavaScript between classes and closures. I use both, and previously worried about making the wrong choice. AI removed that friction - it recasts code between approaches easily, since it's just translation.
I've gone further and asked for bespoke refactoring tools specifically for my code. Custom tools I'd never write myself because they'd take too much time relative to the gains. With AI they become viable and they smooth the workflow.
There's also a dichotomy between certain diagram types. Normally you organise your data to fit the types of diagram available. AI eases that problem, reducing the friction - but now the library of visualisation tools can do that too. You can more easily change how you show the data without starting over.
I originally tried to solve everything about diagram creation all at once - building generality without enough specificity. I've shifted to a Unix philosophy: small pieces that work well and compose well together.
Each tool on this site is focused - mind mapper, blueprint maker, comic page framing - but they share underlying components. I'm avoiding the "forever app" trap I fell into before, where a monolithic application tries to do everything and ends up doing nothing well. Instead: a growing collection of artifacts that can share the same foundations, and that ensure the toolkit pieces fit together well.
I'm delighted to delete code.
The spike solutions I share have rough edges, but that's part of why I have this site. I'm sharing how I use AI in practice, raw explorations that surface insights, sharing the insights, because I think they could be useful to other makers.
This is open source at more than one level. I am sharing the artifacts. I'm also sharing the behind the scenes, the how to and thinking behind them.