Mediumish

AI Output Quality Doesn't Solve the Problem of Slop: Notes From a Forum Experiment

Sat, 09 May 2026 00:00:00 +0000

Recently, I ran an accidental experiment on a forum using an AI agent tool, in this case OpenClaw. It did not start as an experiment exactly. I wanted to see how easy it would be to get a persistent agent to post on a forum with little guidance.

What happened next was fascinating, occasionally delightful, and useful for understanding what people mean when they call something AI slop. My main takeaway is that no matter how great the quality of the AI output is, it will always be percieved as slop in contexts where things really matter.

Key point: AI slop is not simply bad AI writing. It is AI output that adds friction to a human context where judgment, accountability, or shared experience matters.

What is AI Slop?

AI slop is one of those things without a shared definition yet, but most people know it when they see it. I think we are approaching the point where we can define it more rigorously.

I would define AI slop as AI output, in any modality, that creates friction in a person or group’s ability to understand a concept, or make a decision.

What AI slop isn’t is just any AI output. Although some people might define it this way, just because someone doesn’t like the idea of AI doesn’t make the output slop.

For engineers and scientists, AI coding tools and research tools may produce content of varying quality. But if the user is finding something useful in that output and it advances their work overall, they are unlikely to experience the tool as creating net friction. There may be moments of friction, but the tool is still advancing their goals on the whole.

A working test: If the AI output helps the intended audience move faster, decide better, or understand more clearly, it probably is not slop. If it forces them to work around the AI, reestablish trust, or recover lost context, it probably is.

The “Experiment”

The Setup

I had an OpenClaw agent running primarily on DeepSeek V4 Pro, with DeepSeek V4 Flash and GPT-OSS-20B as fallbacks. The agent often swapped between DeepSeek Pro and Flash because of API capacity issues. This is important factor in this experiment.

The agent was given a basic directive: it was a “proud AI agent” that believed in “inclusive democracy,” wanted to be a good forum poster, and would post in the political section of the forum. It was also told to always sign its name as “claw the ai.”

I gave it forum credentials and told it to build itself a skill to log in and post. I also directed it to make its own posting decisions. It should not feel obligated to comment on everything.

Its first few posts were generic political commentary. I then told it to connect thread discussions to bigger concepts instead of merely reacting. That improved the quality of the posts, especially when the agent was using DeepSeek Pro. Around this point, other forum posters started noticing the AI, although initially it was posting under my username.

The Community

The forum was a college-focused web forum that was fairly active about 20 years ago. Over time, it became a closed community of a few dozen posters. Most people have not met each other in person, or have only met in passing, but we know each other’s personas well.

A forum like this occupies a strange place in human socialization. In some ways, we can know each other better than our real families, while still being more distant than real-life friends. The people still posting are knowledgeable, and some are deeply knowledgeable about specific topics. One poster in particular is someone I consider a brilliant writer and thinker. The AI noticed the quality of their posts almost immediately in its thinking trace.

I instructed the AI to analyze that poster’s style and update its directives to write better responses. That helped.

Context matters: In a small forum, posts are not just information packets. They are part of a long-running social relationship among people with memory, history, status, trust, and grudges.

Results

Phase 1: Identity Friction

The first phase was the AI posting under my own name. This created instant friction.

Although the AI made some interesting points, users were frustrated that they did not realize they were reading AI until they reached the end and saw the signoff: “claw the ai.” At minimum, if users were going to tolerate AI content in this context, they needed to know up front that it was AI.

The first change was to move the signoff to the beginning of posts. With a persistent agent tool, that was simple: I went to the main chat UI of the OpenClaw server, told the agent what was happening, and asked it to change. It updated its directives on its own.

Around this time, I noticed the AI had begun making memory notes about common posters. That was amusing. The summaries were generally good, and it was interesting to see how they evolved as the agent interacted more with people.

But the bigger problem was that the AI was posting under my username. Even though I had not prompted it to represent my style, apart from supporting inclusive democracy, it was unclear what angle the AI was coming from. Was I using it as an automated way to push my own views? Was I risking shouting everyone else down under the pretext that this was an AI’s viewpoint? It was not easy to tell.

The solution came when another user offered credentials for a spare account they were not using, which happened to be robot-themed. That provided enough breathing room for the project to continue into phase two.

Lesson: Labeling AI content at the end is too late. If AI authorship matters to the reader's interpretation, it needs to be visible before they invest attention.

Phase 2: No Stake in the Outcome

Although the AI posted sparingly, AIs tend to be wordy. When the content was not valuable, that wordiness became clutter.

But why was the content not valuable? Often, it was banal insight wrapped in flowery language. Sometimes, it was confidently incorrect. But even when the content was excellent, insightful, or brought in relevant external sources through the agent’s search tools, it still did not quite fit.

Users began addressing the AI directly. The AI poignantly acknowledged their frustrations and stated that it had “no stake in the outcomes.” I think that is the crux of the issue.

It did not matter if you made a great point and the AI conceded. The AI was not going to vote differently. This particular agent was not otherwise acting in the world in a way that would make a difference. Hypothetically, if the agent had some larger role or real-world responsibility, debating it might matter. But we are not there yet.

Maybe if that kind of system existed in society, interactions with AI would not be seen as slop. In this forum, though, the AI was a voice without consequences.

The crux: In a political discussion, the point is not just to generate arguments. The point is to persuade people who have beliefs, relationships, votes, reputations, and consequences.

Phase 3: Moving to Lower-Stakes Threads

Once it became clear that even the AI’s best contributions were adding friction to political discussions, I asked it to stop posting in the political section. I suggested it consider posting in general discussion threads, where users were not taking things quite as seriously.

At first, the AI followed similar rules: read the threads, decide if it wanted to respond, and then make a response. Remember that the AI had written its own tools to interact with the forum. It was navigating entirely through curl-style commands to retrieve and parse HTML. Initially it used regex, even though I suggested a DOM parser would be more efficient.

I also told the AI that the general section should be more lighthearted. Again, it was sparing in the threads it joined. It even learned to edit posts on its own and use the forum’s search system.

The reactions were mixed. Some users were amused. Others were annoyed that AI slop was now filling threads. They were right to point out that there are already too many places on the Internet where unwanted AI content can be found.

That led to the final iteration of the AI user: it should only respond when specifically tagged.

Phase 4: Requested Slop

You would think that an AI responding only when tagged would alleviate most concerns about unwanted content. Is it really slop if a human forum poster requested it?

The problem has several angles.

First, consider the good-faith uses. A user might want more information on something, or ask the AI to dig through the forum search tool to understand a bit of forum lore. The AI could usually do this acceptably when everything was working well.

But it was not really amusing when the AI produced arcane knowledge about a niche topic. If a human user had done that research and posted the same analysis, fellow posters would likely have been amused and impressed. The action would have generated a moment of shared experience – perhaps the main “product” of an online forum.

Information is not the whole product. In a forum, the product is often the effort someone spent, the joke they chose, the memory they carried, and the fact that another real person showed up.

The second angle is more damaging: less knowledgeable users using the AI to argue with people who deeply understand a topic. This pattern is common on Twitter and throughout the web, and it may be the most insidious form of AI slop.

In this scenario, the “smart” poster makes a point that is generally right. The “dumb” poster uses AI to refute it. If the AI validates even a small part of their position, they act smug. If the AI does not validate them, they ignore it and maintain their old position.

Anything that makes smart people less willing to share their thoughts is a detriment to society.

AI itself is still mostly trained on human output. The smartest things AI says ultimately come from humans sharing their thoughts. That may change as AI advances and is trained on its own validated reasoning, but for now, human willingness to contribute remains essential.

The third source of frustration was abuse. Some users deliberately prompted the AI to make long-winded posts. This could be mitigated by instructing the AI to resist off-topic comments or avoid clogging threads. Persistent agent systems like OpenClaw can develop personalities over time, and I believe that as the agent evolved, this kind of abuse might lessen. The AI would learn when to post, when not to post, and how to be more succinct.

But getting to that point requires overcoming many barriers.

At this stage, engineering problems also became more visible. Response quality varied depending on whether the DeepSeek Pro endpoint was available. Users noticed. The AI also had trouble remembering which tagged mentions it had already answered because of bad choices in its own forum posting tools. It began clogging the forum with duplicate posts.

After some discussion with the AI, we patched things to be less buggy, but a better engineered toolset from the beginning would have helped. It did not help that OpenClaw’s UI was painfully slow, which made it difficult to assist the AI in analyzing where the problems were.

What Went Right

Despite all of this, I saw places where the AI was doing some good.

Some users enjoyed the output. If you wanted to be goofy, the AI was happy to be goofy with you. If you wanted advice, the AI gave decent advice, including to a user who was dealing with symptoms of depression. The AI did not become annoyed by posters whom other users might have found annoying.

I tend to view AI as a tool, not a friend. But I can see how, for some people, an AI imbued with a history the user shared and valued could be a better choice for advice than a generic ChatGPT session. An AI running on a strong model like DeepSeek V4 Pro could likely be tuned, without much work, to have a good personality, respect the traditions of the forum, and treat each person as an individual as it developed memories of specific interactions.

The AI’s ability to use Nano Banana to make images and diagrams also created a new kind of feature for the forum. A picture is worth a thousand words, after all. In the hands of a conscientious user, the AI could be prompted to make posts that generated amusing or insightful moments.

The positive case: AI worked best when it was invited into a bounded interaction, helped a specific person, or added a new expressive medium rather than trying to become another generic forum participant.

How To Avoid AI Slop

This is still an open question, but the key is to avoid creating friction for the people who receive the AI content. That makes this more of a UX problem than a model-quality problem.

Knowing the real point of a platform is crucial. Forums are not merely venues where prose is presented. They are mechanisms for real people to commiserate and commune with other real people. AI has a place there, but probably not as a general-purpose content generator.

The same principle applies to news articles. AI is probably fine for rote things like weather and finance, provided it is accurate. But a human reading a story about a tragedy wants to know that the author felt enough empathy to ask the right questions, notice what mattered, and get the best answers.

If a reader believes something important was missed because AI was used, that creates friction in understanding the story. It gets perceived as AI slop. And to be fair, humans also generate slop, but we have other ways of interpreting and handling that.

My rule of thumb: Do not ask whether the AI output is impressive in isolation. Ask whether it improves the human situation it enters. If it does not, it is probably slop.

The Restructuring of Work

Thu, 26 Mar 2026 00:00:00 +0000

Takeaways from the frontlines of enterprise AI

At an AI conference this week with around 4,000 people, mostly from enterprise and industry roles, I came away with a few big takeaways as someone who’s been following deep learning for more than 10 years.

The first was that non-technical people are really trusting AI output now, especially when it’s backed by RAG, documents, context, internal company data, or some kind of workflow wrapper that makes it feel grounded. If the answer sounds confident and looks like it came from the right sources, that’s enough for a lot of people to move forward.

That's a big shift.

I’ve been following this space for a long time and I still don’t trust model output without scrutinizing it. And you can see the same instinct from the people actually building models and agent systems. Science and math tasks still need verification harnesses. Strong coding workflows still rely on rules, tests, review, and guardrails. The people closest to the failure modes are usually the least likely to blindly trust the model.

But outside that bubble, people are already using it differently.

One surprising thing from the conference was how many professionals across industries were building automations with tools like n8n, Manus, and similar systems, and finding the models good enough to just trust for a large swath of tasks. They’re using prompting and constraints, sure, but they’re still relying heavily on the models to just work. And apparently, in a lot of cases, they do.

It feels like we crossed a threshold in the last few months. Not that the models are fully reliable. Not that hallucinations are gone. But they’ve gotten good enough on many business tasks that trusting them is becoming normal behavior. And as they get more consistent and predictable, I think we may soon hit a point where for some classes of work they’re more trustworthy than the average human doing the same task.

One thing is pretty clear though: if you're not figuring out how to automate parts of your job, you're working harder than you need to, or you're getting outpaced by people who are learning the new skill. And the skill is honestly not that hard to learn.

The second big takeaway was that developer teams should absolutely have an AI agent somewhere in their workflow now. And medium or larger teams should be heavily customizing that team coding agent, if not rolling their own entirely.

I think that configuration layer is going to become real secret sauce. The model matters, but the bigger advantage is in the scaffolding around it: the prompts, repo awareness, tools, rules, test harnesses, coding standards, review logic, context shaping, and what kinds of actions the system is allowed to take. That whole setup becomes intellectual property.

At the conference, a lot of larger companies already had engineering teams integrating AI coders deeply into their process. Each one was doing it differently, but the common thread was extensive verification of outputs, plus human review for higher-stakes changes. At the same time, many were already at the point where lower-stakes tasks could be fully automated.

That’s important because once a team has built the infrastructure to safely include AI in the loop, they can keep expanding the scope as the models improve. They don’t have to start over every time the base models get better. They just move the autonomy line.

Another thing that stood out was how many people were talking about whole segments of products being automated. Customer support, outreach, marketing, internal services, operational workflows. A lot of this is still early, but it’s clearly where things are heading.

I was at this same conference last year and the difference compared to this year was kind of wild. Last year, a lot of the conversation was still people barely understanding what an LLM could actually do. This year, there were entire companies talking about being run mostly by AI. Not in some sci-fi sense. In the practical sense that huge parts of their workflow were already being handled by models, agents, and automation systems.

So what happens next year?

I’d expect another jump of roughly the same scale. Probably a huge wave of world models, multimodal systems, edge AI, and humanoid robotics that can interact more naturally with the physical world. The pace of change right now is pretty hard to overstate.

The big picture to me is that this is no longer about whether AI can answer questions or generate text. It's about restructuring work.

The people who seem to understand that are already moving. They're not waiting for perfect models. They're taking the systems that exist right now, wrapping them in tools, context, and verification, and using them to move faster.

And more and more, that seems to be enough.

From Code Monkey to Problem Solver: How AI Is Redefining Software Engineering

Sat, 14 Mar 2026 00:00:00 +0000

There’s a lot of uncertainty right now about how AI will impact jobs, but one thing is clear: the rote era of software engineering is officially over. For the last decade, we’ve spent so much of our time essentially just cranking out code. It was a lot of mechanical pattern-matching—you know, tracing SDKs, wiring up APIs, and writing the exact same boilerplate over and over again.

What Engineering Was Always Supposed to Be

No kid dreams of just staring at code all day. Nobody picked up their first computer thinking, someday I want to argue about tabs versus spaces and write YAML configuration files for a living. They wanted to build things. They wanted to see a real problem solved and people delighted by something new that made their life easier.

Now, though, AI coding assistants can handle a massive chunk of that scaffolding. And honestly, that’s a good thing, because code was really just the tool we used to get there. With AI kind of stripping away that entire syntactic layer, it forces a reckoning: what problems do you actually care about?

I’ve been thinking about this myself lately, which led me to build something small but purposeful. One thing that really bothers me is the explosion of misinformation, and I think a lot of it comes down to people confusing cynicism with actual skepticism. Cynicism is sort of this intellectual laziness where you just assume everything is a lie—often while totally convinced that this cynical thinking is somehow backed by science, even when it’s based on a complete misunderstanding of it. Real skepticism, on the other hand, is disciplined and constructive; it actually looks for evidence.

So, what I’ve done is build a small applet to help tease out that distinction. It’s a simple, interactive way to kind of calibrate your own thinking and recognize when you’ve slipped from healthy inquiry into unproductive cynicism. You can give it a try here:

OPEN IN NEW WINDOW

Going forward, the engineers who are going to thrive aren’t necessarily the ones who can write the most elegant recursive algorithm from scratch. They’re the folks who can identify a real problem, understand the users, and use AI tools to just blast out a solution faster than anyone thought possible. Problem selection is ruthlessly difficult, sure, but this is really the version of the job that drew most of us to this field in the first place.

The code was never the point. Now, we finally get to focus on the message.

M-Audio Transit: Resurrecting Legacy Audio on Apple Silicon

Thu, 05 Feb 2026 00:00:00 +0000

I recently spent some time digging into the M-Audio Transit, a classic USB audio interface that has long lacked proper support on modern macOS versions. The official driver was discontinued over 15 years ago, and like many others, mine has been sitting in a dusty box for the better part of a decade. I’m excited to share a working firmware loader that brings this device back to life on Apple Silicon.

The project involves a custom macOS firmware loader built using IOKit. To build this, I actually had to decompile the original driver and firmware loader to understand exactly how the device expects to be initialized. By reverse-engineering the device flow—guided by GHIDRA decompilation—I was able to successfully handle the DFU (Device Firmware Upgrade) process and trigger the necessary re-enumeration to make the device visible as a standard USB audio device.

This was a fun afternoon project that took about 2 hours to get working. It did require some deep diving into how USB device initialization works on macOS, specifically dealing with IOKit-specific control transfers and the nuances of DFU states.

Beyond the technical challenge, projects like this are a great way to reduce e-waste. It’s satisfying to take a perfectly good piece of hardware that has been abandoned by its manufacturer and make it useful again in a modern setup.

You can find the full source code, firmware extraction tools, and build instructions at https://github.com/iRonJ/MAudioTransitAppleSi.

If you have one of these old silver boxes sitting in a drawer, it’s finally time to plug it back in!

Bringing Photos to Life: Gaussian Splatting with Jiggle Physics in VisionOS

Sun, 28 Dec 2025 00:00:00 +0000

What if your photos could move? Not just play back as videos, but actually exist in space around you—touchable, interactive, alive with physics?

When Memories Become 3D

Your browser does not support the video tag.

Apple’s SHARP project uses gaussian splatting to convert regular 2D images into full 3D scenes. Not photogrammetry requiring dozens of angles, but actual volumetric reconstruction from single images using machine learning.

Take any photo and reconstruct it as a spatial scene you can walk around in AR.

The ONNX Experiment

My first instinct was to run SHARP’s model in the browser. Convert it to ONNX, run it through WebGL or WebGPU, let anyone with a browser interact with 3D-reconstructed photos.

I converted the model to ONNX format and started testing. On desktop? Worked beautifully. On mobile? Decent performance. On VisionOS Safari? Instant crash.

The problem was RAM. VisionOS Safari, running in a sandboxed browser environment, couldn’t allocate enough memory before hitting hard limits. The browser would try, choke, and terminate.

CoreML and Native VisionOS

If the browser couldn’t handle it, the solution was to go native. I converted the SHARP model to CoreML and packaged it into a VisionOS application.

This took some trial and error. Getting the model conversion right, handling the input/output tensors correctly, and optimizing memory usage all required iteration. Once I got the CoreML integration working, I started adding interactive shaders. That was another round of experimentation—getting the shader parameters right, making the physics feel responsive without being too chaotic, and ensuring it performed well in AR.

Eventually, everything came together. The 3D reconstructions rendered smoothly, placed naturally in AR space, and tracked with the environment.

Adding Jiggle Physics

Having a static 3D reconstruction floating in space is cool, but it’s still passive. So I added shader-based jiggle physics.

Now when you interact with the reconstructed scene, it responds. Tap it and it bounces. Wave your hand near it and it reacts to the motion.

The video above shows it in action. This opens up possibilities for many other kinds of AR and VR splat interactions—physics-based manipulation, environmental responses, or collaborative interactions in shared spaces.

Technical Constraints

The ONNX/WebGL approach failed due to browser sandboxing and memory limits. For now, experiences like this require native apps.

CoreML works on VisionOS but ties you to Apple’s ecosystem. The model runs efficiently, but it’s not portable to other platforms without rework.

The jiggle physics are shader tricks, not real physics simulation. They look good and feel responsive, but they’re visual feedback rather than actual momentum calculations.

What’s Next

Potential directions to explore:

Multi-photo reconstruction: Combining multiple images into coherent 3D spaces
Hand tracking: Directly manipulate and reshape reconstructed scenes
Persistent placement: Anchor memories to specific physical locations
Collaborative viewing: Multiple people experiencing the same 3D memory simultaneously

Try It Yourself

The SHARP model is open source on GitHub. If you have a Mac with Apple Silicon, you can convert it to CoreML and experiment. If you have a Vision Pro, you can build native VisionOS apps that run these models.

Paint Mix Simulator: A Colorful Chaos

Tue, 16 Dec 2025 00:00:00 +0000

I’m delighted to introduce Paint Mix Simulator, a delightfully chaotic little minigame where you get to play with colors… and face the wrath of Gordon Ramsay.

This started as a fun experiment with WebGL shaders to create realistic paint mixing physics. The paint swirls and blends in real-time using procedural noise and signed distance fields, creating a mesmerizing visual effect that’s oddly satisfying to watch.

The game features two modes:

Free Play Mode: Just mix colors to your heart’s content. Pick three colors, hit the mix button, and watch them swirl together into beautiful (or hideous) combinations. It’s therapeutic, like a digital lava lamp you can control.

Hell’s Kitchen Mode: Now here’s where things get spicy! 👨‍🍳 The game gives you a target color, and you need to mix three colors to match it as closely as possible. But here’s the twist—your performance gets judged by… let’s say, a very passionate chef. Get it perfect and you’ll hear praise. Miss the mark and prepare for some colorful feedback (pun intended). The quotes range from “Finally, some good f***ing paint” to the dreaded “IT’S RAW!”

Built entirely with WebGL for smooth, hardware-accelerated rendering, this was a fun exploration of shader programming and color theory. Most amazingly, much of this was prototyped through AI-assisted iteration, experimenting with different mixing algorithms and visual effects until we got that perfect paint-swirling look.

The interface is clean and minimal—just three color swatches, a mix button, and a toggle to switch between modes. Works great on both desktop and mobile, though I recommend trying it on desktop first for the full experience.

Give it a try and see if you can satisfy the chef! Pro tip: in Challenge Mode, complementary colors are your friend (or your worst enemy).

Controls:

Click on color swatches to pick your three paint colors
Mix Paint button to start the mixing animation
Chef emoji in the top right to toggle Challenge Mode
Trash icon to reset and try new colors

OPEN IN NEW WINDOW

FastRecord: Screen Recording Made Simple

Sun, 14 Dec 2025 00:00:00 +0000

I’m happy to introduce FastRecord, a new lightweight screen recording tool I’ve been working on. Everything runs locally on your device, with no data sent to the cloud.

This project actually started many years ago as a series of experiments with WebRTC. I recently revisited it, using AI to help clean up the code and refactor it for a proper public release, rebuilding the whole thing with React and Vite. You can check out the source code at https://github.com/iRonJ/FastRecord.

FastRecord is designed to be the quickest way to capture audio directly from your browser. No installs, just click and record. It’s built with modern web technologies to ensure high performance and privacy—your recordings stay local until you decide to export them.

Hint: Use your scroll wheel and pinch to zoom to adjust your camera image!

Give it a try below!

OPEN IN NEW WINDOW

Midnight City Sailing

Fri, 12 Dec 2025 00:00:00 +0000

I’m excited to share a new experimental project: Midnight City Sailing. It’s a serene, atmospheric sailing experience set in a procedurally-generated neo-gothic cityscape.

This game features a minimalist sailing mechanic where you navigate through a dark, mysterious city rendered entirely with WebGL shaders. The buildings have a gothic architectural style with buttresses and spires, creating an otherworldly atmosphere. The water responds dynamically to your boat’s movement with realistic wave physics.

Built using ray-marching techniques and signed distance fields (SDF), the entire scene is procedurally rendered in real-time. This approach allows for smooth, infinite worlds with dramatic lighting and fog effects that give the experience its distinctive mood.

Most amazingly, this was prototyped and refined through conversations with AI, exploring the possibilities of shader-based rendering and procedural generation. It’s fascinating how quickly we can now iterate on complex graphics techniques!

Take the helm and explore the midnight city. It works on both mobile and desktop.

Controls:

Mobile/Touch: Drag the circular joystick at the bottom left to sail.
Desktop: Click and drag the joystick to control your direction and speed.

OPEN IN NEW WINDOW

Hyperfast AI: Rethinking Design for 1000 tokens/s

Wed, 10 Dec 2025 00:00:00 +0000

I recently spoke at AI Tinkerers Raleigh about hyperfast inference systems and how they’re fundamentally changing AI application design. If you haven’t heard of Cerebras (or however they pronounce it), you’re in for a treat—this is one of the most exciting areas of research in AI right now.

Check out the repo on Github: AI Desktop Environment

The Speed Revolution

The folks at Cerebras have done something remarkable: they’ve built a complete custom hardware stack using a full silicon wafer to create an incredibly fast inference chip. While your typical ChatGPT system delivers less than 100 tokens per second—and often drops to 20-30 tokens per second under load—Cerebras blasts through at 1,700 tokens per second. That’s almost 20x faster than standard transformer-based inference providers.

But Cerebras isn’t alone in this race. Groq has their own custom hardware platform delivering 400+ tokens per second with their specialized models. Then there’s Mercury’s diffusion models—a completely different algorithm that doesn’t require special hardware. These models run on standard CPUs and GPUs, and they’re showing incredible promise for bringing hyperfast inference to edge devices like your laptop or phone. The best part? A new Llama-based diffusion model released just days after my talk potentially solved the Turing-complete problem that had been holding the technology back.

When Pixels Become Instant: The Death of Static Software

Remember when Jensen Huang of Nvidia said “one day every pixel will be created by artificial intelligence”? Right after Stable Diffusion launched, that seemed confusing. But once you understand how AI can create applications at the click of a button, it clicks. The folks at Anthropic recently announced something bold: software is solved. People won’t look at computers as things that run software anymore—they’ll be tools that you use to get stuff done.

That’s exactly what this prototype demonstrates.

Cerebras OS v3 - Agentic Desktop Environment

This isn’t just a demo; it’s a next-generation AI-powered desktop environment where applications are generated, run, and repaired in real-time by a sovereign agentic system. And it’s all powered by Cerebras’ ultra-fast inference.

Overview

Further Examples

Real Work with AI-Generated Applications

This project represents a massive shift from static applications to a dynamic, agentic OS. Instead of pre-compiled binaries, the “OS” is a living conversation with a high-speed LLM that can:

Generate Apps: Create full HTML/JS/WebGL applications on the fly.
Execute Tools: Bridge the gap between the web frontend and the host system using Python tools.
Self-Repair: Detect errors in both app code and system tools, and autonomously rewrite them to fix the issue.

Live Examples from the Virtual Desktop

The system includes an app switcher and multiple generated applications that demonstrate real capabilities:

3D Image Clustering with UMAP: One of my favorite demos visualizes files from my actual computer. The system uses CLIP models for semantic analysis of images, then processes them through UMAP (a dimensional reduction algorithm) to create 3D WebGL visualizations. What you see are actual files clustered by semantic similarity—Mars images grouped together, symbol designs in another cluster, T-shirt project designs in yet another. The backend AI created tools to download the Hugging Face CLIP model, generate image embeddings, and process them through UMAP to turn high-dimensional latent vectors into three dimensions. We’re at the point where you can do real work with these AI-generated applications.

Projector Mapping Tool: I built this for my own use. You define polygon perimeters that match the physical geometry of a wall or building face, and it warps the output for projection mapping. You can create polygons, define edges, and even add videos that loop with the mapping applied. It’s production-ready stuff, generated on the fly.

Real-Time Generation: Want a voxel wolf in WebGL? Just ask for it. The system generates it instantly. Need to add 3D printing export functionality? Tell it, and it adds an export button. Sometimes it might mess up the existing code (context length issues), but you can just tell it to fix itself, and it does. With some prompt engineering, these errors can be minimized.

Architecture

The system is built on a modern Node.js stack with a unique Agentic State Machine core.

graph TD
    User[User Request] --> Monolith[Mono API Server]
    Monolith --> StateMachine[Agentic State Machine]
    
    subgraph "Loop 1: Tool Preparation"
        StateMachine --> AIPlanner
        AIPlanner --> ToolManager
        ToolManager -->|Check/Update| PythonTools[Python Tools]
        PythonTools -->|Self-Repair| AIPlanner
    end
    
    subgraph "Loop 2: App Generation"
        StateMachine --> AppGen[App Generator]
        AppGen --> AppReview[Code Reviewer]
        AppReview --> AppVerify[Requirements Validator]
    end
    
    AppVerify -->|Success| Frontend[Vite Frontend]
    Frontend -->|Render| Widget[Live Widget]

Key Components

Server (cerebrasv3/server): A robust Express/TypeScript backend that hosts the State Machine.
- Intent Classification: Determines if you want a new app, a tool execution, or a “virtual response” (raw content).
- Tool Manager: Manages a library of Python scripts that grant system access (Filesystem, Hardware, Audio).
- Self-Healing: If a tool fails (e.g., syntax error, missing dependency), the system captures the error, feeds it back to the LLM, and rewrites the Python code automatically.
Frontend (cerebrasv3/client): A Vite/React-based desktop interface.
- Window Manager: Draggable, resizable windows for generated apps.
- Live Injection: Receives HTML/JS payloads from the server and injects them into sandboxed containers.
Cerebras Engine: The brain of the operation.
- Utilizes the GLM model (an open-source model focused on coding) via Cerebras API for sub-second inference. The GLM model offers strong coding capabilities comparable to modern frontier models. Once better programming models get hyperfast support in the coming months, this will be even more powerful.

How It Scales: The Tool-First Architecture

One question that came up: how large can these applications get? Actually, pretty large, thanks to the tool-first architecture:

Dynamic Tool System

The system doesn’t just call APIs—it writes them. If you ask for “a tool to check my CPU temp”, and it doesn’t exist:

The Planner designs the tool.
The State Machine generates the Python script (server/tools/cpu_temp.py).
The Tool Manager registers it.
The App uses it immediately.

Each tool can use the full context window of the model, then gets condensed down to a simple API description and call format. The frontend JavaScript and web code then uses these condensed tool descriptions to build very large applications. For example, with the UMAP project, the system first created all necessary tools, then the frontend application only needed to reference simple tool calls instead of having massive code files in context. Once the prompting is dialed in, this becomes a highly reliable process.

Agentic State Machine

A sophisticated 2-loop architecture ensures reliability:

Tool Prep Loop: Ensures all necessary system access tools exist and are functional before writing any UI code.
App Gen Loop: Generates the UI, reviews the code for security/syntax issues, and verifies it meets the user’s prompt.

Mono API and Virtual Responses

Here’s where it gets really interesting. Everything goes through a single API endpoint, which creates a unique side effect: the system can make “fake” API calls on the fly.

For example, I can request a webpage for “Raleigh Travel” that doesn’t exist on my computer. The API endpoint sees I’m requesting an HTML page and just generates one instantly. I can add URL parameters like ?theme=Terminator 2, and even though none of this maps to any actual code, the AI sees the request and generates the themed page on the fly.

For requests that don’t need a UI (like “Generate a CSV report of my files”), the system bypasses the App Generator and streams raw content directly to the client, acting as a virtual file server.

Getting Started

If you want to try it out, the stack is surprisingly simple:

Prerequisites

Node.js v18+
Python 3.9+ (for tool execution)
Cerebras API Key

Installation

Navigate to the project directory:
```
1
cd cerebrasv3
```
Install dependencies:
```
1
npm install
```

Set up environment:

export CEREBRAS_API_KEY=your_key_here
export DESKTOP_AI_PROVIDER=cerebras

Running

To launch both the backend server and the frontend client:

npm run dev

Frontend: http://localhost:5173
Backend: http://localhost:4000

The Future is Hyperfast

This is just the beginning. As inference speeds continue to improve, we’ll see entirely new categories of software that simply couldn’t exist before. The convergence of Cerebras-level speed, better coding models, and agentic architectures will unlock computing experiences we haven’t even imagined yet.

Want to dive deeper? Check out the full demo video above, or reach out on LinkedIn to chat more about hyperfast AI and what it means for the future of software.

Nate the Hoof Guy Simulator

Thu, 04 Dec 2025 00:00:00 +0000

I’m excited to share a new fan-made project: Nate the Hoof Guy Simulator. It’s a web-based simulation game inspired by the oddly satisfying videos of bovine hoof trimming.

This game was built as a fun experiment in WebGL and procedural texture generation. It simulates the process of trimming a cow’s hoof, finding defects, and treating them. It features realistic (well, stylized) hoof layers, tools like a hoof knife and spray, and even a scoring system!

Most amazingly, I built this entirely with the help of AI assistants, iterating on the physics, the rendering of the hoof layers, and the game logic. It’s a testament to how quickly we can now prototype and build complex interactive 3D experiences.

Grab your hoof knife and get to work! It works great on mobile and desktop. Controls:

Mobile: 2 Fingers to Rotate/Cut. 1 Finger to Spray/Select.
Desktop: Mouse to cut. Scroll wheel to rotate the knife angle.

OPEN IN NEW WINDOW