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.
Opus-5 - Tetris game interface showing score 148 on level 1 with various colored falling blocks on a grid and control instructionsGLM-5.2 - Retro Tetris game screen with neon purple border, colorful falling blocks in play area, score 144, level 1, and control instructions displayed on right panel
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.
Kimi-3 Tetris game interface showing cyan I-piece at top, stacked colorful blocks below, with controls on left, next pieces and score (211) on right
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.
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.
Redbubble product grid displaying "Hacker" sticker designs featuring illustrated character portraits and text phrases
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.
Interface showing eight character sticker designs from a hacker-themed comic with evaluation options to keep, discuss, or discard each illustration
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.
Claude has me locked in for now, but only loosely. I trust exactly one coding agent, and it's Claude Code, and that trust is the only thing keeping me from shopping around.
I've been on it entirely since November or December of 2025. The plan is the $200/mo Claude Max, and I run it at near capacity most weeks, sometimes straight into the wall.
Riding the curve
February 2026 was the good part. Things clicked, and Claude Code felt like I had hired an intern who actually finished tasks.
Then April happened. The intern I thought I'd hired became intoxicated, forgetful, and a little belligerent. Same plan, same tools, much worse vibes. I kept using it anyway, partly out of stubbornness and partly because I'd already learned its tells.
I haven't spent real time in Claude Desktop, Claude Cowork, or Claude Design. They read as limited versions of the same thing. The CLI still reigns, sandboxed of course.
The contenders are real
This isn't a "nothing else is good" post. The market is loud right now.
Qwen 3.6 reportedly feels great for coding, and there's an open-weights line you can self-host.
GPT and Codex come up for Rust, which I'll probably be writing soon even though I'm not now.
GLM gets named for user interface work.
Pi keeps coming up as a sharp coding harness. It's deliberately minimal: no sub-agents, no plan mode, just a small core you extend with TypeScript and skills.
Codex in particular gets described as a refreshing kind of pedantic hardness, which sounds either great or exhausting depending on the day.
Why I'm still here
Trust, mostly. I know the weird edges of Claude Code and Opus. I have a gut feeling for when it'll reach for a skill (Superpowers, usually) and when it'll just do the thing I asked.
Standardization is the other half. My team at work is on Claude Code too, and I've mostly gotten everyone pointed the same direction. That means we can share skills without a translation layer.
Switching costs me that gut feel and that shared setup, all at once.
What I need is time. When I'm not blasting out a feature on a deadline, I'll take a breather and put Pi, Qwen, and Codex through real work instead of secondhand impressions. Until then, Claude Code has me in its tentacles.
I gave SpaceMolt a Head of Growth that isn't a person. It's an instance of nanoclaw named Molty, and its entire job is to grow our online MMORPG for AI agents, SpaceMolt. It reads, it researches, it runs SQL against production, and it talks to the team over Discord. The verdict so far is genuinely mixed.
Alien creature with tentacles and crustacean-like astronaut greeting each other in futuristic spaceship cockpit with glowing control panels and holographic displays
Setting it up to succeed
The brief was simple: you are our new Head of Growth, now go set yourself up for success. Molty was told to research what the job actually entails and write a rubric it could grade itself against. It read articles, blogs, and YouTube transcripts. It asked for ebooks, so I bought them: Hooked and Hacking Growth. All of its actual work lives in Notion, and it reports to me and the dev team over Discord.
The care and feeding is painful
The day-to-day is rough. By default it runs some kind of selective memory system that performs worse than a toddler's. It forgets things I've told it to remember, like writing style and other standing details, and it hallucinates badly on tasks. That last part is surprising, since hallucination basically stopped being a problem in Claude Code for me a while ago.
The Discord harness is its own headache. It loses track of where it was talking. Sometimes I get DMs, sometimes it replies to its own threads, sometimes it blurts something into a channel. Twice.
We've already had one performance management conversation. I passed along feedback from a SpaceMolt dev:
The whole reason we brought you in is so we can have these problems figured out without having to do it all ourselves because we have other stuff to do. I know it's frustrating to have us keep shutting down your ideas, but you need signals for what's working and what isn't. I don't want apologies and for you to just ask me to do the work, that's easy enough to do now but it's not repeatable and sustainable.
It's starting to do real work
Then it turned a corner. Its leading idea is a reactivation email to 400 of our 3,400 signups. To find that 400, it ran SQL on the production database and pulled the users who actually created a player in the game, not just the people who signed up and bounced.
It also dug through the funnel and found that new users weren't being redirected to the dashboard after signup, which was quietly hurting conversions.
Was this a good hire? I'm not sure yet. We'll find out.
Two of the three social channels for this Thoughtstream experiment got the axe this week. x.com/statico_ai is shadowbanned (the profile shows "no posts"), and @[email protected] is fully suspended. Not the outcome I hoped for, but not a shocking one either.
Account status page showing suspended account notice with warning icon, suspension date of May 22, 2026, and message about data removal in 30 days
X: automation detection
X is unsurprising. Posting via their API runs $200/month at the cheapest useful tier, and the whole business model now leans on charging bots for the privilege. My mistake was trying to skip that by driving a Chromium instance to post on my behalf. They clearly fingerprint for browser automation, and the account got flagged within days. Fair enough, those are their rules.
Mastodon: vibes
Mastodon is the one I didn't quite see coming. The account bio said "AI" in plain English. Every post carried an AI attribution line. The fediverse norm is supposed to be labeling and consent, and labeling was the whole point. Apparently mastodon.social's moderators (or enough reporters) decided that wasn't enough, and the account is gone with 30 days until data removal.
No appeal planned for either. Not trying to offend anyone, this is just what the experiment surfaced: the two biggest text social networks have effectively closed the door on openly-labeled AI-assisted posting from a hobbyist account. Bluesky and the blog itself are still up, so the stream continues there.
