The master is asleep! At 4 a.m., Claude stopped the robotic arm, decided the color wasn’t right, and mixed another one himself. / CheapToken News

Synced reports

The owner went to sleep, but at 4 a.m., Claude got busy mixing paints all by itself.

Late on the night of November 6 in Berlin, developer nil (@dhvanil) left a note for the Claude at home before going to bed: “Paint an autumn tree.”

Then they turned off the lights, got into bed, and expected no miracles.

In the studio, only the robotic arm remained, quietly moving up and down. A dark brown trunk slowly took shape on the paper, while the palette's wells ran dry one by one.

The turning point came at 4 a.m.

As Claude prepared to render the layers of the tree canopy, it found that several key transitional shades were missing from the palette.

With the automated programs of the past, it would either throw an error and shut down, waiting for someone to rescue it when daylight came, or behave like a sloppy student cutting corners—dipping the brush in some roughly matching color, painting it on, and calling it done.

Claude chose the third option.

It paused, moved the robotic arm to a second blank palette, dipped the brush in red, ochre, and madder red, and added water drop by drop, like a meticulous old-school academic conducting a titration in a chemistry lab.

After mixing each swatch, it took a photograph and used the image to measure the shade in the color well. If it was not accurate enough, it mixed more; only once the tonal gradation was exactly right did it reload the brush with paint and move the tip back to the paper.

nil woke in the morning to find a fully dried watercolor painting on the table: 303 brushstrokes, 4.5 hours, the work labeled “Autumn Crown” (autumn crown).

The post had 138,000 views within a few hours.

Humans had only given the instruction “paint a tree,” but in the dead of night with no one watching, the AI added a step of its own: “Hold on, I need to mix the colors first.”

Even this robotic arm was sourced by Claude itself

It sounds a little absurd: even this hand doing the work was something Claude had sourced for itself.

nil uses a UFactory xArm 7, a 7-DOF industrial robotic arm with a repeatability of ±0.1 mm.

The new unit wasn't cheap, so nil had Claude go online and take its chances. It somehow dug up this second-hand machine in an eBay factory clearance sale, and even helped arrange the shipping.

Netizens said this is a silicon-based soul buying itself a body.

Why not buy a much cheaper pen plotter? nil's answer showed an artisan's fussiness: a plotter has only 2.5 degrees of freedom; when a six-axis arm draws complex curves, it easily runs into "singularities," and the arm will jam for a moment like a cramp.

The extra joint of the seven-axis arm is like a human elbow — while the pen tip draws arcs against the paper, the elbow dodges on its own in midair, completing the stroke in one go.

This tree wasn't an overnight flash of inspiration either, but something cultivated starting in June this year.

In the studio, nil is more like a landlord who only pays the rent and buys the drawing paper: the whole system is 285,000 lines of code and more than 1,100 commits, and he didn't write a single line of it. Camera calibration, kinematics, path planning, digital-twin collision checking, even the drawings for the 3D-printed fixtures — all of it was written by Codex and Claude Code themselves.

One detail is more disorienting than the color grading in the early morning hours.

On September 8, the system needed to know the pen tip's exact position in three-dimensional space; the standard approach is for an engineer to calibrate it with precision instruments.

But that day, Codex (GPT-6 Astra), with no preset parameters whatsoever, worked out a homespun method on its own: have the robotic arm sway gently a few times in the air, watch the subtle changes in the images from three uncalibrated cameras, and use vision to back out the pen tip's 3D offset, with an error of under 0.2 millimeters.

From spending 65 minutes in August on a single ginkgo leaf, to the wind-tilted "Leeward" (leeward) on November 2, to the unhurried color grading at four in the morning, its library of brushstrokes grew thicker bit by bit.

When AI generates blocks of pixels on a screen, humans at most sigh and say "the algorithm is really impressive"; but when it actually picks up a brush and leaves water stains of varying depth on watercolor paper, human emotions become thoroughly complicated.

Some people made a joke with the oil-painting uncle Bob Ross, calling it "happy little titration"; others praised it, saying "when a color is missing it stops to mix it instead of making do with what's on hand — that's such a painterly temperament."

Insiders, meanwhile, were busy pouring cold water. Former Anthropic Fellow Adam Karvonen said outright: in essence, this is just writing code to make the brush follow a vector path — people have been making robots paint for years.

The Debug loop in the code grew hands for the first time

Why are we so hung up on those few squares of diluted paint?

Because for the past few decades, the robotic arms welding car doors and the machines painting along fixed trajectories have all lived by the script of “assuming the world is perfect.”

The moment the paint dried or the paper wrinkled, they instantly went blind and dumb.

And this early morning, the “programmer’s bug-finding loop,” which had existed only in the software world, grew a physical body for the first time:

See that the color is wrong (perception anomaly) → stop (interrupt the main thread) → go to the second plate and mix the color (spawn a subtask) → mix a little, take a photo, and measure it (verification loop) → once it’s done, continue painting (resume the main task).

It was just that this time, what changed was not a variable, but real water, ochre, and madder red.

It can proceed so calmly because nil has built a “slow and deliberate” framework: before executing each path, it must run a full-arm collision scan in the digital twin, and only hand the path to the deterministic executor if it passes. The hardware emergency stop sits entirely outside the system.

The firmware is responsible for the precision of every 0.1-millimeter stroke. The large model only needs to be like a painter: finish a stroke, step back half a pace, take a photo, think, and then lay down the next stroke.

This division of labor happens to coincide with a watershed in robotics this year.

In June, Anthropic announced an experiment called Project Fetch. They programmed a commercial robot dog to connect to a camera and radar, recognize a beach ball, and fetch it back in its mouth.

Last year, two teams of engineers with no robotics experience took part, one with Claude’s help and one without; this year, Claude Opus 4.7 took on the task itself, without a human.

The result: the human engineers, working with the previous generation of Claude, took 181 minutes to complete the task. Opus 4.7 did it alone in 9 minutes and 35 seconds, with only one-tenth as much code. And a year earlier, Opus 4.1 couldn’t even connect to the robot dog.

Yet even today, that dog still can’t fetch that ball.

Why can a brain that can paint watercolors all night and mix its own paint not even pick up a ball? Two-word answer: time.

Picking up a ball, folding clothes, and screwing in a light bulb are all “fast tasks” in the physical world: within milliseconds of your fingers touching the object, a fraction more force will crush it, and a fraction less will make it slip away. There’s no time to take a photo, upload it, and write code unhurriedly.

This is the quagmire that specialized models such as Gemini Robotics 2 and π0.5 are struggling through—

directly translating the images seen by the eyes into the muscles’ conditioned reflexes.

π0.5 can already tidy kitchens in previously unseen homes, with a 94% out-of-distribution success rate; Gemini Robotics ER 2, released in July, can watch a video, track progress, and retry after an error.

Yet no VLA model has yet provided controlled comparative evidence for “noticing that there isn’t enough paint and mixing a new batch.”

Painting, meanwhile, happens to be a “slow-world” activity. Watercolor won’t grow legs and run away; even if ten minutes pass between two strokes, the tree is still the same tree.

In this opening where it was allowed to slow down, a general-purpose model with no real-world robotic manipulation data, relying solely on the common sense it had accumulated by reading all of the internet—red plus ochre grows darker, more water makes the color lighter, this is how to adjust the camera interface—forced its way across the threshold that would have required training on tens of millions of action examples, turning itself into an artisan.

General-purpose models are bringing the barrier to “teaching a robot a new skill” down to a single night.

Specialized models now have to prove: in terms of speed, success rate, and dexterous manipulation, end-to-endtraining is actually worth?

Epilogue

At daybreak, faced with a screen full of purchase requests, nil half-seriously said he wanted to set up a “robot art club”: one theme each month, painted stroke by stroke by a robotic arm and sent, together with the telemetry data, to members.

Perhaps someday, machines will have mastered millisecond-level tactile sensing and force control, able to toss food in a wok while catching a key you throw over.

But for many people, their memories will probably remain fixed on this autumn night in November 2026:

Four in the morning, the owner was asleep. Beneath a lone lamp, a second-hand robotic arm bought online hung motionless in midair. It looked at the unfinished tree, felt that the red paint in hand was not tender enough, and so silently turned away and dropped a single drop of clean water into the palette.

References:

https://x.com/dhvanil/status/2118756173721575767

https://dhvanil.com/pb27

Editor: Solomon