Mario has a mustache because nobody could draw his mouth.

Back in the early eighties, the screen gave you almost nothing to work with. A character was a tiny grid of pixels, maybe sixteen across. At that size you can’t draw a face, so his designers gave him a mustache instead of a mouth, a big nose so he’d still read as human, a red cap so they didn’t have to draw hair, and overalls so his arms read against his body when he moved. Almost every famous thing about him is a workaround for a screen that couldn’t show more.

That is pixel art. Painting something you recognize instantly, with almost no room to paint it. And lately I’ve been wondering whether AI can do it.

Why I keep coming back to pixels

I’ve always loved this medium and I’ve never been any good at it. The appeal is the simplicity. A whole character in a handful of colored squares, and somehow your brain fills in the rest. It’s a real art, too. Technically it’s just a grid, but a good piece of pixel art is genuinely hard to pull off, and the gap between clumsy and beautiful can be a single pixel.

What pulled me back in wasn’t nostalgia. It was the format. Strip away the romance and pixel art is just a grid of color codes, maybe a few layers stacked on top of each other. That is about as friendly to a language model as a visual medium gets. With a png or a jpeg there’s a barrier. The model can describe the picture, but it can’t really reach in and move things. With pixels there’s no barrier. A model could just write a 16-by-16 grid, or a 32-by-32 one, and that’s it, you have an asset. A character that can jump, get hit, fall over.

And it wouldn’t stop at games. If a model could own asset generation end to end, it could build a whole world out of grids.

I went looking for experiments on how well the models actually do this. I found a few, but nothing that gave me what I wanted. So I ran my own, and put the whole thing in an explorer you can poke at yourself: open the lab.

A short history of painting small

Pixel art didn’t start as a style. It started as a limit. Early machines had tiny resolutions, a few colors, and tight memory, so artists drew straight onto the grid, one square at a time, choosing every pixel by hand. A character was stored as a small block of grid data with a palette, the cheapest way to get something recognizable onto a screen.

Then the constraint became a choice. As screens got better, pixel art could have quietly died, and for a while it mostly did. It came back through indie games that wanted the look on purpose, and now it’s a deliberate aesthetic instead of a limitation. We’re at the point where people reach for low resolution because they like what it does, not because they’re stuck with it.

The tools, and the words you need

If you want to make this stuff today, you mostly open Aseprite. It’s the editor pixel artists actually use. Before I could test anything, I had to learn its vocabulary, because the format is the whole game here.

A sprite is the whole thing you’re working on, the full set of frames and layers that make up your character or object. A frame is one still in an animation. A layer is one level in that stack, the same as in any image editor. A cel is the piece of one layer on one frame, the actual pixels living at that intersection. The word comes from “celluloid,” the clear sheets used in hand-drawn animation.

None of this is complicated, but it matters, because the structure is what an LLM has to reason about. It isn’t painting. It’s filling in a grid, across layers, across frames.

Making it legible to a machine

So I tried to model the art in the form closest to something a model can actually feel its way around: ASCII. A grid of characters, one per pixel. That turns out to sit much closer to how these models seem to think about pixels than a flat image file does. The layers ride on top as metadata, just notes about what each grid is and how they stack.

It’s the same instinct that makes ASCII diagrams work in a terminal. The model isn’t looking at a picture, it’s reading and writing a grid, and a grid is something it can hold in its head.

# rocket.sprite  ·  9x9  ·  frame 1 of 1
# palette:  . empty   W body   B window   O flame

. . . . W . . . .
. . . W W W . . .
. . . W B W . . .
. . W W B W W . .
. W W W W W W W .
W W . W W W . W W
. . . W W W . . .
. . O . . . O . .
. . O . . . O . .

A test set, not really a benchmark

I keep wanting to call this a benchmark and then stopping myself, because it isn’t one, not in any scientific, comparable, leaderboard sense. I just wanted to quickly run a test with a few examples across the different models and see where they stand. It’s just a start, v0.0.0.

It’s five levels, five challenges each. Every challenge is a prompt and a set of instructions. I ran each model inside its own agent harness, Claude Code for Claude, Codex for GPT, Antigravity for Gemini, pointed it at an instruction file, and asked it to work through the challenges one by one and produce the final format. And none of it was one-shot. Each model could render a sprite, look at what it made, judge it, and adjust, looping on the same one as many times as it wanted. I wasn’t after their first guess, I was after their best, so I let them take their time.

Go play with it

Here’s that explorer up close. You can see the static sprites, step through the animations frame by frame, peel the layers apart, and generally play with what each model made.

The short version: they’re all bad, especially at animation. None of them can be trusted to turn out a quality asset. Opus 4.8 was clearly the least bad, the only one that ever reached good, though even it mostly settled at okay. GPT-5.5 and Gemini 3.1 Pro were both stuck at bad overall, with GPT-5.5 the weakest of the three (Gemini honestly surprised me there, I’d have bet it would be the worst). Across all seventy-five attempts, not one earned a perfect. But don’t take my word for it, go look: explore the lab.

My honest take

We’re not there yet. The models are not good at this, and they are especially bad at animation. A static sprite they can sometimes fumble into shape. Ask them to make it move, frame by frame, and it falls apart fast.

Part of it is probably training data. What makes me think it isn’t only the data is that they aren’t great at SVG either, and that’s a similar kind of problem, building an image out of structured instructions instead of pixels pushed around a canvas. Same wall, maybe. Either way, there’s a long way to go.

What I want to see next

The interesting future is the one where a model takes care of its own assets, completely, on its own. SVG, 3D, pixel art, the whole pipeline. That’s a different kind of capability than making a pretty picture, and it’s the one I’m watching for.

For the experiment itself, the next steps are clear enough: a bigger, more solid test set with more scientific, measured evals, and maybe going beyond the language model alone by pairing it with image models instead of asking it to do all the work itself. And I’m genuinely excited to point this at Fable 5 and GPT-5.6 the moment I can run them, just to see how much moves.

For now, the best models in the world can’t quite manage what a handful of people pulled off decades ago, with a grid sixteen pixels wide and a mustache. I find that oddly comforting, but I can’t wait to watch it change.

It used to be a weekend and a wish. Now it’s a creature I’m not sure I can keep up with.

We keep pet projects to learn. To stretch a skill, to poke at something new, and mostly to have fun. That’s always been the deal. A small thing on the side, no deadline, no users, no stakes. You feed it when you feel like it and you put it down when you don’t. You’re raising it for the joy of raising it.

I still start them the same way. But lately I look up from one and the thing has gotten strange. The way I work on it has changed. The craft has changed. The idea is bigger than anything I’d have dared call a hobby a year ago. Somewhere along the way the small familiar project I started turned into a whole different creature, and I’m still working out what it is.

The itch is the same

The reason I start one hasn’t moved. I’m curious. Something new shows up in the world and the only way I really learn it is to build something with it. Right now the new thing is agentic coding. A new toolset, a new way of working, a whole new way of building. The field is young and most of it is still being worked out in the open. So the pet project is doing exactly what it always did. It’s how I learn the new by playing with it. If anything it’s more alive than it’s ever been, because nobody knows the final shape of any of this yet, and that’s the best part.

I keep reaching higher

Here’s what changed first. The ideas I let myself reach for got bigger. I go big now. Things I would have called too much for a hobby, I just start them, and every time one of them comes together I get a little bolder. The ambition feeds itself. The more the thing can do, the more I let myself want from it.

The ones I never dared start

We’ve all got ideas we never dared start. The ones that needed a team, or a budget, or a month I was never going to find, so they just sat there, waiting politely forever. Now I reach for one and actually build it. The waiting is finally over.

They’re not so innocent anymore

The moment I start one, a quiet question comes with it. Could this be something. A product. A company. A small startup hiding inside a weekend. The old pet project was innocent, art for the sake of art, made because making it was enough. These ones arrive with ambition already attached. It’s harder to build just to build when the thing in front of you might actually go somewhere. The play has stakes now.

I keep a whole pack now

It’s never just one. One idea becomes three, all open at once, all demanding attention. More is reachable, so I reach for more, and suddenly I’m keeping a pack. The question I keep avoiding is whether there’s enough of me to go around. There’s one of me and a whole pack of them, and that math has stopped working out.

It’s barely coding, and the play is different

The whole thing is different now, not just bigger. It’s less coding than it used to be, or a different kind of coding. More describing and steering and deciding, less typing the actual lines. A pet project was always part play and part practice, a fun way to sharpen a skill on the side. That hasn’t changed. What changed is the game and the skill themselves. I’m practicing a craft nobody can quite name yet, with rules that keep shifting while I learn them. I’m still playing. I’m just not sure what game it is anymore.

Everyone’s keeping one now

It’s not only us, either. The scene got crowded. A pet project used to be a coder’s thing. Now it feels like everyone has one. People who never wrote a line are out here building their own.

We’re all turning into generalists

Even the coders are wandering off their patch. I watch engineers pick up design so the thing looks good and feels good, not just runs. The work pulls you into the parts you used to hand to someone else. We’re all stretching wider than we trained for. Whatever the work needs, we learn it.

The meter is always running

Nobody mentions the cost much, maybe because nobody really minds it. Everyone’s paying for a subscription now, usually more than one, and they aren’t cheap. We feed these things tokens by the bucket and we do it gladly, wallets out, take our money. There’s something odd in the shape of it too. A few AI lords now tax us for access to intelligence itself, and every month we line up, happy to pay.

Mostly I’m just showing off

Half the time I’m building, but not really to build. A new model lands, or a new release, and I lose the evening to it. I make something just to try it, to test it, to feel the breakthrough for myself and show it off to whoever’s around. The project becomes the demo. Half of what I make now is really a showcase for the model that made it.

The hype never lets up

All of this is a lot. Under all the excitement there’s a tiredness I don’t always admit to. A new tool every day, a new technique, a new thing I’m apparently already behind on. The FOMO is constant, and so is the push to try the next thing before it goes cold. Keeping one project alive was fun. Keeping a dozen of them going while the ground keeps shifting under you is its own kind of exhausting. The excitement is real. So is the burnout, sitting right next to it.

The quiet fear underneath

There’s a fear under all of this too, and I think most of us carry some version of it. That the same technology making me feel powerful is quietly eating the thing I do. The craft, the jobs, whole industries. That it’s going to be bad for us in ways we can’t quite see yet. Everyone I talk to has it, but everyone copes differently. Some are in flat denial, heads down, this is fine, nothing’s really changing. Others go the other way and merge straight into the danger, all in, betting the safest place to stand is inside the thing that scares you. Most of us are somewhere on that line, picking a defense and hoping it holds.

We’re forgetting how we used to build

Maybe we’re letting some of it go. We build at a higher layer now, up in the text and the concepts and the architecture, further and further from the actual code. The lines themselves matter less when the machine can produce them. I take this seriously, though. I still try to keep it together and be an engineer, because in my opinion vibe coding alone doesn’t cut it. If anything, knowing the craft makes me get more out of this, not less. The focus just moved, from the syntax to the shape of the thing. Still, I wonder what happens to the old skill if we all stop practicing it. I keep telling myself a new and better kind of engineering will grow up in its place. Maybe it will.

So what is this now?

I look at what I’ve been building, and at what I’ve turned into while building it, and I don’t really know what either one is anymore. The hobby, the craft, the product, the fun. They all became something else while I was busy enjoying them.

It’s still mine. Bigger than I meant, stranger than I expected, but mine. So I keep building. You probably do too. Where we all end up with this, I honestly can’t guess.

I barely open a chat anymore.

Like many, I left chat-only interfaces for agentic ones months ago. In AI time, that’s ancient history. I switched from Claude Chat to the Claude Code + Obsidian combo, and it paid off better than I expected.

This is how I work now, and how I get there.

The shifts

Setting up the tools takes an afternoon. That part’s easy. You need the tools, but that’s not the shift. The real shift is in the attitude and habits they pull you into.

1. Switch the setup

It starts with the setup. Mine went from Claude Chat to Claude Code + Obsidian.

They’re coding agents. They create files, take action. They don’t just talk back.

Everything lives in one folder, my homebase for all my creative and knowledge work. The files are mostly Markdown. Each project is a subfolder. Say I start an illustrated storybook (a little fox who’s afraid of the dark), and a storybook/ folder fills with .md artifacts as the agent and I work. That storybook is the running example I’ll carry through the rest of this piece.

That folder is shared ground. Claude Code and Obsidian both point at it. I run a few Claude Code sessions, in the terminal or the desktop app, whichever, and read and edit the same files in Obsidian. It’s just my file view; I skip the linking.

The setup enforces three things:

• A bias to creating files. They’re designed to read and write files and run commands, so they default to making files. That alone changes how you operate.

• An extended surface. The chat isn’t the only place you work. Input and output aren’t trapped in the chat anymore. They extend into files and folders. You type into the chat less; you write, edit, and read in files instead.

• Not just talking. There’s still a chat, often several. But the work shifts to delegating tasks, shaping the input and context, and reviewing the output. For the storybook, one session develops the story and characters while another draws the pages I’ve already written. It’s like a small crew working with me on the same shared context and files.

2. Think in files

The work lives in files now. I keep all of them in Markdown, just plain .md files. It gives the text a light structure (headings, lists, formatting, the occasional table), and editors like Obsidian handle it well. But it isn’t just plain text. A file has a type, based on its content and structure. It might be a brain dump, a research note, a design doc, a spec, a character sheet, a prompt template.

Every document takes its own shape, with a type, an outline, and content of its own. And it plays a role, working as a reference in context, or as the input or output of a process. Same .md, different documents.

I want to called them artifacts, a piece of my AI vocabulary now. To me, every .md file is an artifact. I shape it, name it, keep it, and it lives in the folder, not on the chat surface.

Plenty of them aren’t keepers. They’re intermediate or temporary, made to think with, like a braindump, a list of options, a scratch plan. Those move the work as much as the finished pieces.

Take the storybook. It grew these files one at a time, as the work needed them. Each is named for its type:

• idea.braindump.md — the raw first dump: the fox, the dark, the feeling I’m after.

• foxes.research.md — what real foxes are like, and the bedtime books I want it to feel like.

• story.design.md — the arc: scared fox → the turn → brave fox; page by page.

• fox.character.md — the fox herself: shy, curious, big ears. She feeds the pictures.

• style.rules.md — the soft, warm look and voice every page holds to.

• page-01.page.md — one page: its words and its picture. (I make more of these than anything else.)

The name carries the type, like .braindump, .research, .design, .character, .page. Each holds its own few sections inside. And they feed each other. Research feeds the character; the character, the plot, and the style become the story; and the story loops back to shape the fox. All of it becomes the pages. Then I refine, and pull it together.

I don’t force a rigid type or form, though. I don’t pre-define what sections, format, or language each kind of document must have. The words carry their own weight. Natural language is the most dynamic, versatile tool we’ve got. Keep it that way.

3. Reach for tools

The agent doesn’t just write files. It calls tools, and it connects to what you already use. This is a big one.

It searches the web and drops the findings into foxes.research.md. It pulls in files you already have from Google Drive or your email. For the storybook, it calls an image model to draw the fox and her dark forest, then writes a quick script to shrink the file sizes without touching the images, checks the result, fixes what’s off, and saves them in the same folder. And on like that, as far as you want to take it.

These are tool calls. The agent decides it needs something, reaches for the right tool, and folds the result back into the work. And you’re not limited to what’s built in. MCP (the Model Context Protocol) is the standard plug for wiring in your own. Connect a tool or service once, and it’s there from then on.

The more you connect, the more it does for you, and you never have to leave the folder.

4. Build a system

Files and artifacts need a structure. The human and the AI need a shared model to work in. In short, you need a system.

Luckily, the agentic tools hand you the way to build one. It’s a context file called Claude.md (or agent.md), the prompt that’s always there, where you set how things work.

Here’s the gist of mine, shortened from the file at the root of my homebase (the full version is in the repo):

# Homebase

The one folder where everything I make and learn lives, mostly Markdown. Each project is its own domain, its own folder.

The mental model is simple. Thinking happens in files. The chat steers; the files are
the work.

## How we work

- **Parallel sessions.** A few agents on a shared folder; I steer from the editor.
- **Two surfaces.** Align in chat, make the work in files (~20/80, adjustable).
- **Think in artifacts.** Every file has a type and a role; even scratch files count.
- **My input is sacred.** My taste and direction are the source of truth.
- **Respect my time.** Concise and dense, no fluff.
- …

## Structure

CLAUDE.md       — what this is, how we work, the rules
_system/        — shared tools, scripts, conventions
domainA/        — one folder per project, its own domain
  CLAUDE.md     — per domain context, its name, what it is and why, how it works, its guides, do's and don'ts
domainB/        — e.g. a storybook, a game, a blog
domainC/        — e.g. a research vault, a course

Look at those rules. Parallel sessions, Two surfaces, My input is sacred. Simple lines, but they make a huge difference.

The storybook is just one of those domains, with its own folder and its own CLAUDE.md holding the fox’s world and the book’s style.

It starts lean and grows as I work. It gets opinionated, it becomes mine.
Skills.md is another piece some lean on; I use it lightly, but mostly I’d rather improvise.

5. Build context and momentum

I don’t think of this as chatting with a machine that just passed the Turing test.

The work becomes building context incrementally and finding momentum in the right direction.

I build context by gathering more of those .md artifacts. Direction and momentum emerge as I instruct and judge, as I add my tokens, my taste, and my opinion. It isn’t a vibe or a snapshot; it’s an arrow that sharpens with every bit of input. It builds, it speeds up, it points.

Take the storybook. It starts with almost nothing, just a fox, the dark, a feeling. I open idea.braindump.md and dump it, fast and raw. The agent diverges and brainstorms off it; then we converge, researching the foxes, designing the arc, drafting the first page. Each step leaves an artifact, and the context thickens.

The first page is slow. I’m finding the look and the voice at the same time. By the fifth, the forest is set, the fox is herself, the style holds, my intent is sharp, and I know where it’s going. Each new page comes fast. I’m not starting over, just adding to a book that already knows what it is.

The catch

There’s inertia at the start. It’s a cognitive shift, and it was hard to switch. The old habit had opinions.

But once the habit forms, the payoff is huge. The tools fade into the background. What stays is a different way of thinking, one that lives in files, in systems, in momentum. You won’t miss the chat box.

If you want to work this way, my homebase is one context file to drop in: github.com/nnehdi/homebase.