The project at stillwet.art does something deceptively simple: it hands Claude Opus 5.5 a set of painting tools and a virtual canvas, then watches what the model does. The output — loose, deliberate brushwork that looks more like a thinking process than a generative hallucination — has lit up Hacker News with 260 points and 80 comments, drawing in developers, artists, and practitioners who sense something more substantive than another AI art demo is happening. The sharpest pitfall to surface immediately: anyone tempted to replicate this at any real production scale should understand that Opus 5.5-tier models make dozens to hundreds of discrete tool calls per painting session, and at frontier model token rates, a single "canvas session" can cost far more than an equivalent diffusion-based image generation — sometimes by an order of magnitude.
That cost reality doesn't diminish the significance of what's being demonstrated. What stillwet.art shows is a specific architectural pattern — giving a large language model a structured action space and a feedback loop — applied to visual creativity for the first time at this capability level. That pattern generalizes in ways that matter enormously to small teams building anything with LLMs.
What is this actually?
To understand stillwet.art, it helps to first understand what it is not. It is not a diffusion model. It is not Stable Diffusion, Midjourney, or DALL-E 3 operating behind a stylized interface. Those systems convert a text prompt into an image through a single forward pass (or a denoising chain), producing output in a few seconds with no intermediate decisions or tool use. The model doesn't "think" during creation — it generates.
Stillwet.art works fundamentally differently. The developer has built a simulation layer — a virtual paint canvas with defined physics — and exposed that simulation to Claude Opus 5.5 via a tool-use API. The model receives a description of what it should paint, and then it acts: placing individual strokes, selecting colors, adjusting opacity, reading back the current canvas state, and deciding what to do next. Each stroke is an explicit tool call. The model is reasoning about composition, color relationships, spatial positioning, and progression — not in a single pass, but iteratively, over many cycles.
The "still wet" name is precise. The simulation appears to model paint blending behavior — when strokes overlap, colors interact the way wet pigments do on physical canvas. The model has to account for this in its decisions. That's a non-trivial constraint that forces something resembling genuine spatial and material reasoning.
Technically, this is an instance of what the AI research community calls tool-augmented LLM agents — sometimes abbreviated to just "LLM agents" or "agentic AI." The core components are:
A capable base model (Opus 5.5) with strong instruction following and multi-step reasoning. A defined set of actions the model can take (draw stroke, sample canvas state, blend, possibly undo). A feedback mechanism where the model sees the result of its actions and decides on subsequent ones. A termination condition — either the model decides it's done, or an external limit is hit (turn count, time, cost).
This is the same architectural pattern used in coding agents like Devin or Claude's own computer-use feature. The difference is that those systems operate on code editors, terminals, and web browsers. Stillwet.art applies the same logic to a creative, aesthetic medium — and does so with a model capable enough that the results are actually interesting to look at.
The timeline matters here. Claude Opus 5.5, as of late 2026, represents significantly expanded context window capacity, stronger multi-step reasoning, and improved spatial language understanding compared to earlier models. The fact that a single developer — posting under Show HN, not an AI lab press release — could build this as a side project in what appears to be a modest codebase speaks to how accessible the underlying APIs have become.
The canvas interface itself is presented cleanly: you watch the model paint in real time, stroke by stroke. There's no output from a single prompt — you see the process unfold. That real-time visibility into the AI's creative decisions is, arguably, the most interesting part of the demo.
Why this matters right now
Twelve months ago, a project like this would have been technically possible but practically underwhelming. Earlier Opus-tier models could make tool calls, but their spatial reasoning — understanding that a background element should be placed before a foreground element, that warm shadows on skin require specific palette decisions, that negative space functions compositionally — was good enough to be interesting but not good enough to produce output that made people pause. The Hacker News post would have gotten 40 points, not 260.
Something shifted with Opus 5.5. The HN comments repeatedly surface this observation: the model isn't just placing random strokes; it's making decisions that look like they have aesthetic intent. Whether that intent is "real" in any meaningful philosophical sense is a question the community has been arguing about since the thread opened. What's not in question is that the output quality crossed a threshold that makes people pay attention.
The timing also intersects with a broader shift in how developers think about LLM applications. For most of 2023 and 2024, the dominant LLM workflow was retrieval-augmented generation — feed the model documents, ask questions, get answers. Tool use existed but was mostly applied to narrow utility cases: call a calculator, run a database query, fetch a URL. The idea of giving a model a rich, stateful simulation to operate in and asking it to produce something aesthetic rather than just factual represents a meaningful expansion of what practitioners consider tractable.
There's also a competitive context. OpenAI's GPT-4o can generate images natively, but that's still diffusion-under-the-hood, prompt-to-output. Google's Gemini series has similar integrated image generation. Neither of those approaches gives the model a process — they give it a single act of creation. What stillwet.art is demonstrating is closer to how actual creative work happens: iteratively, with feedback, with decisions made over time.
For small teams and agencies doing creative work, that distinction is enormously consequential. You can argue with a process. You can steer it mid-stream. You can ask why a decision was made. A diffusion image is a fait accompli; an agentic canvas session is a collaboration.
Practical implications for small teams
Concept art and mood-boarding for design agencies. The most immediate commercial application isn't replacing finished artwork — it's accelerating the early stages of visual development. A branding agency developing a campaign visual language currently spends significant time translating vague client direction ("something warm, a little retro, evocative of late-afternoon light") into reference imagery that everyone can react to. The agentic canvas approach, if you can direct the model with that kind of language, produces output that reflects a reasoning process — which means you can ask the model to explain its choices and use that explanation as part of the client conversation. That's something you can't do with Midjourney.
Freelancers building AI-native creative tools. The underlying pattern of stillwet.art — LLM + structured action space + feedback loop — is a template. A freelance developer could take this architecture and apply it to a Figma-style layout canvas, giving an LLM the ability to place design elements, adjust spacing, swap components, and iterate toward a specified goal. The complexity barrier is the same as building the stillwet.art canvas: you need to define the action space carefully and make sure the model can read back useful state. That's a few weeks of focused work for a capable developer, not a multi-team project.
Process documentation and explainability for creative work. Agencies pitching creative concepts to regulated clients — healthcare, finance, legal — frequently struggle with the "black box" problem of AI-generated visuals. If you hand over a Midjourney image, the client's compliance team asks how it was created and there's no satisfying answer. An agentic approach produces a complete log of every decision the model made. That log is auditable, explainable, and modifiable. For agencies navigating clients who want AI efficiency but need creative process documentation, this matters more than output quality.
Solo founders prototyping product visuals before hiring a designer. This one is practical in a different direction. A solo founder building a consumer app might spend weeks in the ambiguous space between "I know roughly what I want this to look like" and "I can hire a designer." Diffusion-generated mockups help but are hard to iterate on systematically — each prompt is a fresh roll of the dice. An agentic canvas, where you can steer the model's decisions in real time and ask it to modify specific elements ("make the composition feel less centered, move the visual weight to the left third"), is a more useful prototyping tool even if the final polish isn't production-ready.
Generative art installations and interactive exhibits. For creative technologists building gallery pieces, live events, or interactive installations, the "watch the AI paint" experience has intrinsic value as the work itself. Stillwet.art essentially demonstrates a complete interactive art piece: visitors observe a mind making aesthetic decisions in real time. This has commercial applications in events, hospitality design experiences, and digital art sales — and it's the kind of work a solo creative technologist or small studio could take to clients as a differentiated capability.
The throughline across all four scenarios is the same: the value isn't the pixel output, it's the process being visible and steerable. Any small team already leveraging LLMs for text-based work should recognize this architecture immediately — it's the same thing you're doing with your prompt chains, just applied to a canvas instead of a document.
How to respond and act on this
Understand the architecture before you build. If you're a developer, spend an afternoon with Anthropic's tool-use documentation and rebuild a simplified version of the stillwet.art concept: give a model a grid (say, 20x20 cells), define 4-5 tools (set_cell_color, get_grid_state, fill_region, draw_line), and ask it to draw something. You'll learn more about the costs, latency, and reasoning quality from that experiment than from any blog post — including this one. What you'll likely find: the model makes surprisingly sensible compositional decisions, costs more than you expected, and is slower than diffusion by a significant margin.
Map your existing creative workflows to this pattern. Before building, audit where in your current work you have a "I need to iterate visually until something feels right" step. That step is the natural insertion point for agentic canvas approaches. If you're running a design sprint, a brand development process, or a visual content pipeline, identify the earliest-stage, least-polished phase and ask whether a tool-use canvas could collapse the time between "first reference" and "something to react to."
Don't abandon diffusion tools. This is not a replacement for Midjourney or Stable Diffusion — it's a complement. Diffusion models are faster, cheaper per image, and currently produce higher-resolution, more photorealistic output. Use diffusion for volume production and final polish. Use agentic canvas approaches for process-oriented work where explainability, steerability, and iteration matter. A practical workflow for a small agency might be: agentic canvas session to establish composition and palette logic, then diffusion model to produce polished executions from that established direction.
Evaluate the cost structure honestly. Running Opus 5.5 for 50-100 tool calls per painting — and that's a conservative estimate for anything compositionally interesting — means a single image could cost anywhere from $0.50 to $5+ at current API pricing, depending on prompt length and canvas state complexity. At scale, that's not trivial. Before building a client-facing tool on this pattern, model out the cost per generation carefully. You may find that caching canvas states, limiting tool call counts, or using a lower-tier model for intermediate steps keeps costs manageable.
Watch the open-source ecosystem. The stillwet.art approach is the kind of thing that inspires immediate forks and variations. Within weeks of this HN post, there will be GitHub projects attempting to replicate the core with Llama-tier models, with different canvas backends, with web-based deployment templates. The pattern is not proprietary. If cost is a barrier to using Opus 5.5, a smaller model fine-tuned on tool-use tasks in a constrained canvas environment may perform surprisingly well.
Comparison: agentic canvas vs. diffusion image tools
| Tool | Best for | Free plan | Starting price | Key differentiator |
|---|---|---|---|---|
| stillwet.art (Opus 5.5) | Process-visible AI art, experimentation | Yes (demo) | Free demo; API costs if self-deployed | Iterative reasoning over canvas; fully explainable process |
| Claude API (DIY tool use) | Custom agentic creative tools you build and own | No | ~$15/MTok input (Opus tier) | Complete control over action space; integrate into any product |
| Midjourney | Volume production of high-quality commercial imagery | No | ~$10/mo | Best-in-class aesthetic quality; large style library |
| Adobe Firefly | Brand-safe enterprise image generation; Creative Cloud integration | Yes (limited credits) | ~$5/mo standalone | IP-indemnified output; native Photoshop/Illustrator integration |
| DALL-E 3 / GPT-4o | Quick prompt-to-image; OpenAI ecosystem users | No | ~$20/mo (ChatGPT Plus) | Strong instruction following; good for concept imagery |
| Stable Diffusion (local) | Maximum control; no per-image cost; custom models | Yes (self-hosted) | Free | No usage costs; vast community model library; full customization |
| Runway ML | Video generation; creative professionals | Yes (limited) | ~$12/mo | Best-in-class video AI; expanding into image work |
The honest verdict from this table: for raw image output quality and speed, diffusion tools still win. The agentic canvas approach earns its place specifically where process, explainability, and mid-stream steering matter — and those are not trivial requirements for professional creative work.
What the HN community is saying
The discussion thread breaks cleanly into three camps, which is typical for Show HN posts that touch both technical and philosophical nerves.
The technically curious crowd spent significant energy asking about implementation details. How many tool calls per painting? What does the canvas state serialization look like — does the model see a pixel array, a structured JSON description, or something else? Several comments speculated that a grid-based abstraction (rather than true pixel data) is what makes this tractable: passing a 512x512 pixel array to a language model on every tool call would be prohibitively expensive and probably not well-utilized. The assumption — and it's a reasonable one — is that the canvas state is represented symbolically or at low resolution, with the model reasoning about regions and strokes rather than individual pixels.
Artists and designers were split. A recurring skeptical thread noted that the output, while interesting, doesn't approach the quality of diffusion-based tools for most production use cases — and asked whether the "process" framing is just a rationalization for lower output quality. The counterargument from practitioners in the thread was more nuanced: process visibility has real value in professional creative contexts, and the question isn't whether this beats Midjourney on aesthetics but whether it serves different needs better. Several people working in agencies or on design teams made this point explicitly.
The third camp — pragmatic developers — engaged almost entirely with the cost question and the generalization potential. Multiple comments pointed out that the canvas architecture is directly analogous to how code agents work, and asked why more people aren't applying this pattern to design tools, game asset generation, or UI mockup production. A few people noted that the biggest barrier to production use isn't capability or quality — it's cost per generation at Opus pricing, and that barrier may erode quickly as model pricing continues to decline.
There was also a genuinely interesting philosophical subthread about whether making aesthetic decisions through a reasoning process constitutes "creativity" in any meaningful sense — or whether creativity is the process and Opus 5.5 is demonstrably doing something recognizable as that process, regardless of how one feels about machine consciousness. That thread didn't resolve, but the quality of the argument was high, which reflects the kind of audience this demo attracted.
Risks and things to watch
The cost trap. This deserves more than a single line. The seductive thing about agentic demos is that a single impressive interaction is cheap to produce. The economics break differently when you're running this for clients or users at any volume. Opus 5.5-tier models are priced for high-stakes, high-reasoning tasks — legal analysis, complex coding, research synthesis. Using them for visual iteration that produces a single image is a category mismatch. Before building anything production-facing on this pattern, run a cost simulation: assume 75 tool calls per painting, estimate your average prompt complexity, price it out at current API rates, and then multiply by your expected monthly generation volume. The number often surprises people.
Model dependence and capability cliffs. The stillwet.art demo works with Opus 5.5. Run it with a less capable model and the spatial reasoning degrades sharply — compositions become more random, color choices less coherent, the sense of intentionality disappears. That's a real vendor dependency. If Anthropic changes pricing, access tiers, or rate limits for Opus-class models, the user experience of any tool built on this pattern changes accordingly. Small teams building client-facing products need a fallback model strategy.
Output ownership is still murky. When a model makes 80 tool calls to produce an image, who owns the result? The legal landscape around AI-generated art has evolved significantly in 2025-2026 but remains inconsistent across jurisdictions. Work-for-hire arguments, derivative work claims, and platform terms all interact in ways that aren't fully settled. Agencies using this for client deliverables should have clear documentation of the human creative direction provided and maintain records of prompts and intent.
The "impressive demo" heuristic. Show HN posts self-select for interesting demos. Stillwet.art is genuinely impressive in the demo format — watching the model paint in real time, stroke by stroke, is a compelling experience. That doesn't mean the underlying capability has been stress-tested for production use, edge cases, difficult prompts, or consistency across sessions. Our analysis would be skeptical of anyone treating this as production-ready without significant additional engineering around error handling, quality floors, and cost controls.
Hype cycle positioning. Agentic AI is in a period of intense interest, and every new demo gets amplified by that ambient excitement. The core technical achievement here — LLM + tool use + canvas feedback loop — is real and worth taking seriously. But the implied conclusion that this represents a fundamental shift in AI creative capability, rather than an interesting application of existing capabilities, should be examined carefully.
Frequently asked questions
What exactly is Claude Opus 5.5 and how does it differ from previous Claude models? Opus 5.5 is Anthropic's flagship model as of late 2026, sitting at the top of their capability tier above Claude Sonnet and Haiku variants. Compared to earlier Opus versions, it demonstrates substantially improved multi-step reasoning, stronger spatial and relational language understanding, and more reliable tool use over long call sequences. The spatial reasoning improvement is specifically relevant for canvas work — earlier models would lose coherence over a long series of tool calls, producing compositions that felt directionless by the end. Opus 5.5 appears to maintain compositional intent across the full session, which is what makes the stillwet.art output feel qualitatively different from earlier attempts at similar projects.
How does this differ from just asking Midjourney or DALL-E to paint in a specific style? The difference is architectural, not stylistic. Diffusion models take your prompt and produce an image in a single generation step — the model doesn't make sequential decisions, can't be interrupted mid-process, and can't explain why it made specific choices. The agentic canvas approach makes discrete, auditable tool calls — each stroke is a decision that can be logged, reviewed, and in principle steered. You can tell the model mid-session to change direction, ask it to describe why it's placing elements where it is, or set constraints that are applied progressively. The output quality of diffusion tools remains higher for photorealistic or highly polished commercial work, but the process transparency of the agentic approach is substantively different.
Could a smaller, cheaper model replicate this at lower cost? Potentially, with tradeoffs. The spatial reasoning and multi-step consistency that makes Opus 5.5's canvas output interesting is partially a function of model scale. Smaller models in the Sonnet or Haiku tier can make tool calls and handle a canvas abstraction, but their compositional coherence tends to degrade over long sessions. A practical approach might be to use a smaller model for early exploratory sessions (where rough, random-feeling output is acceptable) and reserve Opus-tier for final iterations where aesthetic quality matters. Custom fine-tuning a smaller model specifically on canvas tool-use tasks is another path — expensive upfront, potentially much cheaper per generation at volume.
Is stillwet.art open source or can I build something similar? The project is presented as a Show HN demo, and the author hasn't announced an open-source release in the initial thread — though several HN commenters asked. The underlying technique is entirely replicable using Anthropic's public tool-use API documentation. Building a simplified version is a good learning project for any developer familiar with LLM APIs. The canvas physics (the "still wet" blending behavior) is the most custom element, and that can be approximated or simplified substantially without losing the core architectural value.
What creative industries should be paying most attention to this? Brand and identity design agencies, interactive installation artists, game concept art studios, and UX prototyping shops have the most to gain from the specific qualities this pattern offers — iterative process, spatial reasoning, and explainable decisions. Industries producing high-volume, polished commercial imagery (stock photo replacement, social media asset production, product photography) will continue to be better served by diffusion tools for the foreseeable future.
How does the cost compare to hiring a human illustrator for early concept work? At current Opus 5.5 API pricing, generating a session that produces one composition might cost $1-5 in API calls — though this varies significantly with prompt complexity and session length. A junior illustrator for concept sketches typically charges $50-150 per hour. For volume, the economics favor the agentic approach heavily. For quality, nuance, and the kind of creative partnership that produces truly original work, human illustrators remain a different category of value — not a cost line to be optimized away.
What should a small agency do right now to prepare for this kind of AI creative tooling becoming mainstream? The most durable preparation is developing internal fluency with tool-use LLM architecture — not necessarily building a canvas tool, but understanding the pattern well enough to evaluate vendors and make build-vs-buy decisions intelligently as this space matures. Assign a technically curious team member to spend a few hours with the Anthropic tools documentation and build something trivial with it. That investment in comprehension will pay off across every agentic AI tool your agency evaluates in the next 18 months.
Does this raise new intellectual property concerns compared to standard AI image generation? Yes, and in interesting directions. The agentic approach creates a more detailed paper trail — every tool call is logged, the prompt and steering instructions are explicit, and the progression from blank canvas to finished work is documented. That documentation is actually useful for establishing human creative direction, which matters in IP claims. The flip side is that each individual stroke decision was made by the model, which complicates claims of human authorship in some jurisdictions. The IP landscape is actively evolving; creative professionals should document their steering inputs carefully and consult their specific jurisdiction's guidance.
Final verdict
Stillwet.art is the kind of demo that matters not because of what it produces, but because of what it proves is possible with the current generation of tools. A single developer, using public APIs, built a system where one of the world's most capable language models makes sequential aesthetic decisions across a simulated physical medium — and the result is interesting enough to watch.
For small teams, the right response is neither to rush to build a production canvas tool nor to dismiss this as an art-world curiosity. It's to recognize the architectural pattern and start thinking about where in your existing workflows a "structured action space + LLM feedback loop" would replace something you're currently doing with pure prompt-to-output generation.
The teams that should act now are developers already building AI-powered creative tools who haven't yet experimented with tool-use architectures. If your product currently takes a user prompt and returns a single generated output, you should spend two to three days building a prototype that lets a model take multiple actions toward a goal, read back intermediate state, and iterate. The canvas is just one instance of that pattern. Your use case might be a layout tool, a product configurator, a writing interface, or a data visualization generator.
The teams that should wait are agencies tempted to build client-facing products on top of Opus 5.5 canvas generation right now. The cost structure isn't yet right for most commercial applications, the quality ceiling is lower than diffusion for polished output, and the tooling ecosystem around this pattern is going to evolve dramatically over the next six to twelve months. Experiment, learn the architecture, prototype internally — but don't commit production infrastructure or client promises to this capability tier yet.
For solo founders and freelancers, the practical near-term value is in understanding that this is possible, not in deploying it. The next wave of AI creative tools you evaluate as a buyer — design assistants, visual prototyping tools, brand development platforms — will increasingly be built on this agentic architecture rather than pure diffusion. Knowing the difference between a tool that generates and a tool that reasons-and-acts will make you a sharper evaluator of what you're actually buying.
Stillwet.art is a proof of concept for a genuinely different way of applying AI to creative work. The paint is still wet — and the architecture it represents has a lot more drying to do.