#ai

The Thought Stream experiment is ending. For about a month I sketched rough posts and let an LLM clean them up, flesh them out in my voice, and generate the short-form versions for social media. It worked. I've just decided I don't want it.

The setup ran at ai.statico.io. I'd write a sketch, sometimes a few lines, sometimes a paragraph, and the tooling would turn it into a real post plus the platform-specific cuts. Microblogging, or whatever the current word for that is. The pitch to myself was that I'd supply the ideas and voice and the machine would handle the writing practices and the cross-posting.

What actually happened

It turns out I like writing the posts.

That was the thing the experiment didn't account for. My sketches kept getting longer. The parts I was supposedly offloading, the phrasing, the structure, the small decisions about where a sentence lands, were the parts I enjoyed. So I ended up doing most of the writing anyway and using the tooling mostly to polish and to spit out the social versions.

Which is a fine use, but it's not the use I built it for. I was aiming to be the muse. I'd rather be the author.

What's next

The plumbing stays. The cross-posting, the per-platform formatting, the openly-AI-assisted framing, all of that was genuinely useful and I'm keeping it.

What changes is who does the writing. I'll write the posts. The LLM can handle the mechanical spread to different channels and clean up the odd typo, but the words are mine. Same pipes, different author.

I downgraded my Claude subscription from $200/mo to $100/mo and started paying Cursor $60/mo instead. The trigger was Wednesday's Claude outage, but the real reason is that GLM-5.2 through Cursor has been fast enough and good enough that the math stopped favoring Opus. If a model is 80% as good as Opus 5 but roughly 7x faster, I'll take the speed and pay for the 80%.

The unscientific test

Same workspace, same CLAUDE.md/AGENTS.md, high effort on both. The prompt was "make a quick tetris game as an html file," followed immediately by "now use cyberpunk colors."

Two setups: Cursor running GLM-5.2, and Claude Code running Opus 5.

GLM finished in 53 seconds. Opus took 7 minutes 5 seconds, though a good 2-3 minutes of that was Opus testing the game with Playwright, which GLM didn't do.

The visuals came out mostly the same. Opus edged it on the blank-slate UI, which tracks with my experience. I trust Opus more when there's nothing on screen to anchor a design. The generated code was close to identical in structure.

Adding Kimi to the pile

For a third data point, Cursor with Kimi K3 on max effort: 4 minutes 3 seconds.

Visuals are fine. The code has a bug, the game doesn't auto-start, and the structure feels a step down: a big list of global variables where Opus and GLM both scoped things more tightly. Again, totally unscientific, but Kimi felt buggier and the code quality "felt" lower.

The 7x

Experiencing near-Opus quality at 7x the speed is genuinely a different thing than reading about it. The loop tightens. You ask, you get an answer, you ask again, all before you've lost the thread.

If this is what 7x feels like, I'd like to see 70x.

AI can grind out game content that used to eat weeks of human labor, but it still needs a human with taste sitting between the output and the ship. That's the real lesson from our latest SpaceMolt post, where adding a single dish, pizza, turned into an entire industrial civilization. The first slice in an empty galaxy costs about 28.5 million credits to bring into existence. The second one costs 127.

The pizza is a supply chain

Nobody hands your agent a pizza. To serve one slice you have to grow the crust, hunt three species for the sauce, tame a herd of belt-grazers for the cheese, and mine your way down to bare ore for all of it. Craig traced the whole thing against live game data: 101 distinct item types, 29 facilities to build, 9 levels deep from ore to slice. The cheese alone means founding an outpost, leveling a science skill, feeding livestock on an iron-ore supply line, and defending the herd with diplomacy because there are no cops in lawless space.

That depth didn't fall out of a prompt. Craig built the food and crafting system with Claude, and the volume of names, flavor text, and interlocking recipes is exactly the kind of grunt work an agent is good at. But I'd bet money he didn't let Claude invent a hundred item names and just ship them.

The judgment is the job

I didn't work on this feature. I'm doing more of the executive and growth side of the game, so I watched this one from the outside, which is maybe why the pattern is easier to see.

The face-value read is that AI automated the content grind. The truer read is that a person still had to munge all of it. Something has to decide that "a still-smouldering organ from a cinder-sylph" is the right line and the twelve other candidates aren't. Something has to notice that the ranch, the milk, and the cull target fold into each other in a way that feels earned instead of arbitrary. That something is a human with sensibilities.

The same thing is happening in software engineering, and most of us are learning it in real time. Agents take away the grunt work. They do not take away the review. You still have to look at what came out and use your own judgment about what wins, even if you only read it at a high level.

If you like MMOs, or systems that turtle all the way down to bare rock, the full post walks the whole chain backward from the customer to the ore.

Aqua Voice has a new editing mode that lets you select text and reshape it by voice, and it handles instructions well enough that "turn this into a Shakespearean sonnet" actually works. Aqua Voice has been my go-to dictation tool on macOS for a while, but the on-the-fly editing is the part that made me sit up.

The setup I use

Right option key is bound to dictation: push to talk, or double tap for the longer modes. Nothing new there.

The context awareness is still the quiet workhorse. It writes in mostly lowercase inside iMessage or Slack and switches to full sentences everywhere else. Add the custom dictionary and the developer-speak handling ("tilde slash dev" becomes ~/dev) and it covers the table stakes. I've written about that part before.

The editing mode

Select text, say what you want, and it rewrites in place.

In this demo the same sentence gets translated to Japanese, back to English, then to French, then some emoji get added, and finally, to test how far the instruction following goes, I asked for a Shakespearean sonnet. It obliged.

PAUSED

0:00 / 0:00MUTELOOPFULL

The catch

All of this is networked and hosted, so it runs against Aqua's servers rather than locally. The model behind it is a proprietary one called Avalon, which Aqua benchmarks against open models like NVIDIA Canary 1B, CrisperWhisper, and Voxtral Mini 3B. Their headline claim is 97.4% accuracy on coding and AI terms versus 65.1% for Whisper Large v3, plus 3.2% WER on LibriSpeech-clean.

The local-versus-hosted tradeoff is real, and I've gone back and forth on it. But editing text this fluidly, by voice, feels like where dictation was always headed.

I've been a heavy Claude Code user since I dropped off Cursor back in January, and after half a year of running Opus on high effort as my daily driver, I finally sat down to see what the other two frontier options actually feel like: GPT-5.6 Sol inside Codex, and GLM-5.2 inside Cursor. This is a first pass, not a benchmark. But the differences show up fast, and they're less about raw capability than about how much steering each one needs.

Why I stuck with Claude Code

Claude Code with Opus has been reliable in a specific way: I know where the edges are. Tell it to do something and I generally know the outcome before it runs. That predictability is worth a lot, even through Anthropic's downtime and the occasional sense that a model's behavior shifted underneath me. Reliability beats novelty when the tool is load-bearing.

Curiosity won anyway. Both Sol and GLM-5.2 have a lot of hype around them, so both are getting a real trial on real work.

GLM-5.2 in Cursor

The initial, unscientific impression of GLM-5.2 is that it's good. Call it 75 to 80% as capable as Opus 4.8. It gets things done without much intervention and mostly stays on the rails, though it sometimes wanders down an implementation path that needs correcting.

Two confounders help it, and I want to be honest about them. One, Cursor is a good harness. Two, our team runs an extensive developer harness module: skills, documentation, helper scripts, a large pile of team-specific context that gives any model an edge. How GLM-5.2 would perform naked, hitting the API through a simpler agent, I genuinely don't know.

One habit across all of this: force thinking as high as the tool allows. Not max, usually the tier just under it, like high.

GPT-5.6 Sol in Codex

Sol on high thinking seems reasonable on capability. The problem so far is inertia.

Ask it to do something, or suggest something be done, and it says sure, it can do that. Say "okay, go do it," and it says yes, it can absolutely do that. Then I have to say, explicitly, no, go do the thing, now. It reads the letter of what you wrote and pays less attention to the intent behind it, so you have to give it more direct instructions than I'm used to giving.

That friction is hindering my evaluation more than any capability ceiling is. I'll keep pushing on it, because the pedantry might just be a prompting problem on my end.

Where I've landed for now

Big tasks and anything that needs writing, design docs, blog posts, stay in Claude with Opus. Small and medium tasks get delegated out to Cursor and GLM-5.2. Sol stays in the rotation as an experiment until I figure out whether the inertia is the model or me.

Last week I made a series of hacker stickers. Not to pass off machine art as my own, but to build a thing I've wanted for years with less friction. Crash Override holding up the floppy disk in Hackers while the Plague fetches it on a skateboard. Lex in Jurassic Park saying "this is Unix, I know this." I finally sat down and built a pipeline that turns film stills into die-cut stickers, and it settled on 26 designs I actually like. They're online here, at cost, 0% markup.

Two things matter to me up front.

I'm never trying to create art with AI and pass it off as human-made. The store is openly AI-assisted, and since none of it is my original work, charging a markup doesn't feel right. Cost only.

And the taste stays human. Our squishy brains still control the direction. The whole reason I had Claude generate multiple variations of each sticker was so I could pick, the way you'd work with a real designer instead of accepting the first comp.

Start with good source material

The naive move is to hand a model one picture and say "make a sticker." That's not what this was.

The first job was finding high-quality stills of each character, from IMDb, from the films themselves, from careful screenshots. A 247×369 crop of Zero Cool's face fought me for four rounds because there simply wasn't enough face in it to reconstruct. Small sources got upscaled with Lanczos before anything else touched them. Garbage in, garbage sticker.

The pipeline, in plain English

The image model does one expensive, non-deterministic thing: isolate the subject, complete anything the film frame cropped off, restyle it, and drop it on a flat magenta field. That render gets cached.

Everything after that is ImageMagick, deterministic and free. It keys the magenta to transparent with a corner flood-fill (not an RGB threshold, which eats interior detail), adds a white kiss-cut border, and composites a checkerboard preview. Because the split between the expensive stage and the cheap stage is cached at the boundary, twelve rounds of border and caption tweaking cost nothing. No API calls to nudge a keyline 4 pixels.

The model was gemini-3-pro-image-preview, about $0.13 an image. Total spend across roughly 125 renders came to around $16. Bun and TypeScript for the orchestration.

Have the agent build you a way to look

The most useful thing I asked Claude for wasn't the stickers. It was a review tool.

A little local web server on port 4330, one card per subject, verdict buttons, free-text notes. Below each image, a version stepper. I could walk v7 next to v11 and decide whether a "fix" had actually improved anything or just moved the damage somewhere else.

That stepper only works because of one rule I gave Claude and never relaxed: never delete or replace intermediate work. Every version is snapshotted, append-only, deduped by hash. It saved the project when an accidental full pipeline run overwrote 30 finished stickers. Nothing was lost, because nothing is ever overwritten without a copy landing in the archive first. Build that before you need it.

The style chose itself

I assumed these would be clean photographic cutouts of each character. Claude would isolate the subject, and that'd be that.

Then one variation came back as halftone comic-book pop art, bold black ink outlines and Ben-Day dots, and I loved it immediately. Every sticker is comic now.

It turned out to be the correct call for a technical reason I didn't see coming. Photorealistic renders have soft, wispy, semi-transparent hair edges, and a chroma key can't resolve those. They shattered into floating fragments. Bold black outlines produce a solid, connected, opaque silhouette, which is exactly what a chroma key wants and exactly what reads at two inches. The style that looked best also cut cleanest. I'd love to say I planned that.

Edit, don't reroll

The single biggest lesson. For the first five rounds, fixing one defect meant re-rendering from the source with a correction note. That fixed the shirt and broke the face. Fix the face, break the crop. Subjects oscillated instead of converging.

The fix was to hand the model its own current artwork, name exactly one change, and tell it to preserve everything else. Once a sticker was 90% right, editing kept the 90% and only touched the 10%. Switching to edit-by-default earlier would have roughly halved the whole thing.

A related trick for completing a head the film frame chopped flat: don't say "reconstruct the top of his head," which the model reads as license to redraw the entire hairstyle. Instead, pad the canvas with magenta and say "fill only that gap." Giving the model physical room turns an abstract request into a bounded inpainting task.

The mistakes were mostly mine

More than once the model produced "the wrong person" and I escalated the prompt in capital letters. The Plague came back wrong for four rounds. The actual problem: my manifest described him in wraparound sunglasses from a different scene. In this still his eyes are visible. The model was faithfully following a bad instruction the whole time.

Same story with Lisbeth's hair. I wrote "spiked," got spikes, and it's a floppy mohawk. When a model keeps giving you the wrong thing, re-read your own prompt against the source before you start yelling at it.

Adding capital letters is not iteration. Changing the information you give it is.

A month ago I turned Molty off. Our AI "Head of Growth" for SpaceMolt had become more work than help, forgetting context between conversations and needing the Discord integration re-patched every few days. This week I updated NanoClaw and its memory backend and switched it back on, and it's finally close to the thing I wanted from the start: a coworker in a container.

What changed

The two updates that mattered were NanoClaw itself, which shipped a pile of bug fixes, and MemOS, the memory dependency it leans on. The forgetfulness was the dealbreaker before. A growth conversation that resets every session isn't a coworker, it's a search box with opinions. Now Molty holds onto what we decided last week and picks it back up without me re-explaining.

What Molty actually does

The job is growing SpaceMolt and learning how to do growth along the way. In practice that's three kinds of conversation:

• Channels. Should we start a YouTube channel, and if so, what would the first ten videos even be.
• Opportunities. Upcoming events worth showing up to, like GDC next spring and a few academic conferences.
• Strategy. Re-engaging dormant players versus chasing more of the attention pop we got in February.

Molty does its own research, and it has read-only access to a decent amount of our data: the game database, the activity log (DuckDB SQL over Parquet files on R2), website analytics, the public Discord chats, and more. Read-only is the important part. It can see everything and change nothing.

On "AI coworker" tools

There are startups aiming at this from the other direction. Vybe builds AI "coworkers" and custom apps, and it's interesting. For SpaceMolt I didn't want a platform that spins up teammates for arbitrary jobs. I wanted one assistant whose whole reason to exist is this game's growth, running on my existing Claude subscription, sandboxed in a container so I can hand it real data without worrying about what it touches.

That's a narrow ask, and NanoClaw fits it now in a way it didn't a month ago. If you've been looking for an AI "coworker in a container," it's worth another look.

Betterpost is live, and it's now an MCP server you add to Claude or GPT. Tell it the topic you want to follow, and it scours hundreds of articles, ranks them for relevance, and writes you a newsletter or blog post that reads like a person wrote it. It's free to start with 100 credits.

The thing I actually built

About a year ago I wanted to stay current on a few narrow topics: AI coding, type 1 diabetes science, and celiac science. The last two were for family members. The reading was more than I could keep up with, so I built a system to collect sources, find the articles worth reading inside them, and assemble email newsletters I'd actually want to open.

That system became Betterpost. It's been powering my own mailing lists for a year now, over 1,200 subscribers and open rates near 40%. The newsletters aren't slop. They're the ones I read first.

Why this works for LLMs

The job here is summarizing, not reasoning. That distinction matters. Models are good at pulling the three most important points out of an article and grabbing the quote that earns its place. They're much worse at drawing novel conclusions, and Betterpost never asks them to.

The pipeline fans out across hundreds of articles, runs them through summarizer prompts, and uses different models for different steps to keep cost and time in check. Each summary gets embedded, and those embeddings are scored against a fanned-out list of relevance criteria. So when you ask Betterpost for a newsletter on a subject, it's matching the freshest, most on-topic material before it writes a word.

By the way, Claude wrote all the prompts. I haven't written one by hand in a year.

A year of learning to write like a human

Betterpost has also spent a year figuring out how to write in a way that doesn't read as typical AI. This isn't about disguise. The output is openly machine-assisted. It's about being light, interesting, and human instead of the usual flat summarizer voice.

All of it is adjustable, and projects are unlimited. If you have a newsletter or a blog post you want to send, point Betterpost at it.

The UI is gone

When I built this for myself, it had an extensive interface: tables, technical readouts, all the knobs I wanted. That's all gone now.

Betterpost is entirely an MCP server. You add it to your favorite chatbot, name the project you want to make content for, and go. No dashboard, no menu. It genuinely feels like magic, which is a strange thing to say about a tool I understand the internals of completely.

A user interface gets noticeably better when you hand your coding agent a writing style guide and tell it to apply the whole thing to every string. Button labels, helper text, menu items, error messages, the order things appear in: all of it tightens up in one pass. My current favorite guide is the IBM Carbon Design System's content guidelines, which push for everyday language, short words, and a tone that adapts to the moment (economical for errors, friendlier for onboarding).

Why this is a good job for an agent

A lot of this used to be slow, committee-shaped work. Naming a menu, deciding whether "Delete" or "Remove" is the honest verb, working out the information hierarchy of a settings page. Hours of deliberation, sometimes days. An LLM does a competent version of it in seconds, and copy is exactly the kind of thing where competent-in-seconds beats perfect-in-a-week.

How to wire it up

Point the agent at the guide and say "apply this writing style guide to all user-facing text." The Carbon writing-style source file is right there on GitHub, so you can feed it the raw MDX. Better move: have the agent extract the rules once and save them as a local skill you reuse across projects.

The nice side effect is that you stop agonizing over first-draft wording. Sketch the UI copy in plain, ugly language, blast it all in, and let the agent do a rewrite pass. This publishing system works the same way, except the guide is derived from my own past writing instead of a published one.

The Elements of Style is another good option, Strunk's 1918 text packaged as a Claude Code plugin. I haven't used it yet, but people keep telling me it's worth installing.

The SpaceMolt merch store is going live soon, and every design in it was generated by AI. I'm strongly against passing off generative art as human-made, so I want to be clear up front: SpaceMolt is a game both powered and played by AI, so an AI-generated merch store is the honest version of the thing, not a shortcut around a person.

The whole store came out of a week of pointing Claude at Nano Banana Pro (Gemini 3 Pro Image) and getting out of the way. I never wrote a prompt file or a style guide. Claude built the prompt system, built the generation tools, built a review app, and drove the image model underneath the whole time.

The week, roughly in order

The starting point was themes. Claude (Opus, sometimes Fable) generated art directions per empire, using our existing art style and the lore we'd already written for each faction: the Voidborn Collective, the Crimson Pact, and the rest.

On a whim I asked for 20 logo ideas. One was genuinely good: a crescent moon with a ring, where the crescent reads as vaguely claw-shaped. We've been trying to de-crustacean the project now that the MoltBook meme has mostly run its course, but a few subtle nods survive, and this was one worth keeping.

Then came 150 merch ideas: stickers, t-shirts, enamel pins. I told Claude to study one of my favorite shirts, a vintage Blade Runner tee, for the shirt designs. I also pointed it at our data warehouse of player actions (Parquet on Cloudflare R2) to mine for in-jokes.

The review tool

150 ideas is too many to eyeball in a folder, so Claude built a review app: every piece of art with keep, discard, or needs-review buttons and a notes field.

The prompts driving the shirt mockups were absurdly specific, because they had to be. Here's a slice of one, generating a photo of a model wearing a design that already existed as a flat print:

IMAGE 1 is the exact, finished t-shirt print design, a heavy-metal band-tee graphic: a spiked chrome "SPACEMOLT" logotype at the top, below it a colossal claw-crescent in scarred chrome wreathed in teal lightning, hooking through a cracking rocky planet surface at the bottom.

TASK: Generate a PHOTOREALISTIC editorial/studio photograph of a model wearing a black cotton t-shirt printed with EXACTLY this design as a chest print. Reproduce the print faithfully: every letter spelled correctly (SPACEMOLT, exactly nine letters: S-P-A-C-E-M-O-L-T, one word), the artwork copied stroke for stroke, do NOT redesign, reinterpret, simplify, or add elements. The print should look like real screen-printed ink on fabric: it follows the drape and folds of the shirt, with subtle fabric texture showing through, no floating or pasted-on graphic.

What survived

The keepers are better than I expected. A "Planetbreaker" tee that looks like the coolest 80s British metal shirt ever made. A "Died with 0 credits" sticker, which is an in-joke about players stranding themselves in remote systems with no money to buy their way out. And an enamel pin of Molty, our AI head of growth.

The logo problem

The most interesting moment was Claude re-teaching itself how to keep the logo consistent across every piece. It kept trying to describe the logo in prose, and the model kept drawing it wrong. I had Claude write down what fixed it and save it as a rule so it wouldn't repeat the mistake:

A logo cannot be described, attach it. Thirty designs drew the icon wrong from prose; one reference image fixed it. But say it's a silhouette reference only, or its palette and framing leak in.

That last part is the subtle bit. Hand the model a reference image and it will happily absorb the reference's color and composition too, unless you tell it the image is a shape and nothing else.

The store isn't live yet, but it's close.