Built a beeswarm of Epoch AI Notable AI Models releases over time. Each mark is a model; horizontal position is publication date.
It's a modern-day marvel! The wizards are here, to save us from writing code by hand. We cast a spell and the code appears. But when we keep pushing, it doesn't feel like magic anymore. It feels... bad. We find ourselves churning out slop, even the most fastidious among us.
Well, maybe the answer is more agents. Spin up many agents to work in parallel. Do it across your whole team, and congrats! You can change the code faster than you can think about what to change. You have 50 PRs piled up, waiting for your review. Choose between being the bottleneck or slinging agents and half-assing it.
After a while...
What's going on?
I have a few ideas.
First, let's go revisit the good old days. What did it used to look like to create our chart?
The old flow
First, we research and plan.
Gather the necessary ingredients: where might this live in the codebase and product? What's already there?
Are there components we can re-use? Should we render the spinner in canvas or svg?
Next, we write some code.
Stub out a new React component, add it somewhere so we can test it out.
We probably need a way to handle the animation timing.
It's alive!
Maybe we dig around the Framer Motion docs, find some relevant examples.
Oh look, this one has keyframes and spins! Maybe we'll incorporate that.
Let's render some stuff!
Where are our images?
Great, plop those in and set up our keyframes.
Check it out in the site.
Oh no, that keyframe is backwards!
Hm, maybe I like it that way… I'll ask Sam what he thinks.
Writing code and observing it and planning and tweaking and on and on.
In the flow. Running through a tight loop.
Until we're satisfied and creatively expressed.
Throw this in a PR
and grab a congratulatory coffee.
See how we weren't just "writing code"? We were exploring the problem, making decisions, evolving our understanding of the code, problem solving with teammates. Writing code was our medium for thought, where we figured out what we wanted. Our code evolved with our thinking, going from "fuzzy" to "clear and granular" in tandem.
We're not going back to this way of working. Honestly, I don't think we should.
But I do believe that we'll regain our flow state once we figure out our new workflow and build tooling to supercharge it. IDEs have had many decades to smooth our previous ways of writing code.
There are many historical eras of building computer programs. At first, an instruction was a physical thing: a hole punched into a card, fed into a machine.
Punch cards led to assembly, which let us write words instead of punching holes. Mnemonics gave us a small, human foothold in the machine.
Compilers let one line of FORTRAN or C stand in for a screenful of assembly. We could describe more of what we meant, and less of how the machine should do it.
Scripting languages took over the bookkeeping: memory, types, all the fussy parts. The details receded, making room for a tighter loop between an idea and the thing itself.
Libraries and frameworks let us borrow whole subsystems instead of building them. At each step, we handed more detail to a translator and spent the savings on ambition — creating more, faster, and with less.
We’ve been half-assing the next step. We can steer code in whatever medium fits us, but we’re still using prompts and reviewing raw code, which is impossible to eyeball. Zoom out and you get… unreadable code. So we revert to throwing another agent at the review.
Modern language models grew out of both language-modeling and machine-translation research. AI agents can translate our code to any medium and back, increasingly robustly. Our previous attempts (UML, no code) failed largely because there was nothing keeping them in sync or making them an editing surface. Every translation had to be done manually.
We've been offered an amazing possibility of working with code and products in whatever medium we best think in.
What might it look like to explore what we're building, instead of just reading the source?
What if agents created a custom whiteboard or playground for us, as soon as we started working? Complete with panels for any facet we might want to polish? Maybe we don't even start with code! How far can we explore using images or a prototype, until we're resolved on a direction?
This is just a silly demo, but maybe it can help you imagine a future where building with code feels grounded and engaging.
If we only use AI as a faster way to edit code, we'll keep losing our intuition, mental map, and team alignment. We thought code was the output (bring back the "I convert coffee to code" mugs), but code was also where we did our thinking. We're finally able to build tools that let us think in more human ways. Where can that take us?