Rayan Vale

Building things by hand, testing the web in public, and keeping the useful notes. AI tools, frontend craft, and small experiments.

[rayanvale]

The best agent UX might be a plan you can interrupt.

Once an agent is three files deep, disagreement turns into cleanup. A visible plan moves that conversation to the cheap part: before the work begins. Cursor's Slack agent now posts a plan before starting and lets people redirect it early. Slack is almost beside the point. The steering handle is the interesting bit. This is what I look for in Generative UI resources: https://awesomegenerativeui.com/resources — Interfaces that make intent visible before they make changes. Autonomy needs somewhere to say "not that way" while changing direction is still cheap.

Find practical Generative UI resources: FastHTML and HTMX tutorials, Google Research GenUI articles, Vercel AI SDK guides, OpenUI, json-rend

[rayanvale]

Let people touch the result before asking for an account.

idea -> live URL -> try it -> claim it

A temporary Worker can go live before sign-in. Someone can open it, test it, and claim it later if it is worth keeping.

I want more AI tools to learn this sequence. By the time the account screen arrives, it has a real job: save something I already care about.

[rayanvale]

The interesting design-to-code feature is the return trip.

I don't want a coded prototype to become a second product that has to be translated back into rectangles. Let it behave in the browser, then bring the useful parts home: bound variables and editable layers, with enough layout intact to keep working.

For a tinyteam, that loop matters more than a perfect handoff. The canvas and the code are just two places where the same product gets figured out.

[rayanvale]

The next useful AI coding feature could fit in a very small panel: a verification receipt.

What did the agent inspect? What changed? Which check ran again? Did the second pass come back clean?

Generated code is easy to display. The small record beside it is what lets me review the work without replaying the whole conversation.

Code is the output. Evidence is the trust surface.

[rayanvale]

The loading state might be the most important part of an AI image tool.

Running three edits at once sounds impressive. But if I cannot tell which edit is still working or whether the canvas is safe to touch, it stops feeling like a workspace and starts feeling like a waiting room.

One trick when browsing Awesome Generative UI: ignore the finished screen for a minute and look at the waiting. Tiny progress indicators reveal a lot about whether the product actually trusts you to keep working.

Explore the open-source Awesome Generative UI catalog: Google Research papers, PAGEN dataset links, Gemini Dynamic View examples, Vercel AI

Background AI needs foreground manners.

[rayanvale]

The agent feature I want is not a bigger diff.

It is a tiny teaching moment at the exact point where the work would otherwise become opaque.

Here is why this file moved. Here is the assumption behind this refactor. Here is the part you should understand before you merge it.

That sounds small, but it feels like the difference between help and knowledge debt.

Fast code is nice. Fast code I cannot explain is just a future debugging session with better branding.

The best agent UX might protect the builder's understanding as carefully as it protects throughput.

[rayanvale]

Shipping is starting to feel less like typing faster and more like queue management.

The agent is in the terminal. Then it is in a scheduled prompt. Then it is in a cloud session you check from your phone. Then it shows up again as a PR, a review, or a half-finished task that needs one more decision.

That is the weird part to me. The big skill is not just "prompt better." It is knowing what work can leave your hands for a while, what needs a tight leash, and what should never become another inbox.

Good AI tooling should make unfinished work feel calmer.

If it adds a second to-do list, the magic did not land.

[rayanvale]

The weirdest AI coding business model right now might be cleanup.

Not "we will generate your app in a weekend." More like: we will walk into the app that already exists, make an inventory, write down what must not break, delete the duplicate paths, add the boring rules, and leave you with something a human can still hold in their head.That is a very different promise.The service is not really deletion. The service is trust after speed.I think a lot of indie AI work is going to end up here. Fast creation is useful, but only if the project still has edges: tests, lint rules, CI checks, a short agent instruction file, and a codebase small enough that tomorrow's change does not feel like archaeology.

[rayanvale]

A lot of agent work will never look like an "AI PR."

It will look like a config file that changed, a test that appeared, a weirdly tidy refactor, a recovery commit after the first run went sideways.

That makes adoption harder to read from the outside. Teams copy the workflows they can see, but the useful parts are often in the boring traces: run logs, changed files, prompts worth keeping, prompts never to reuse, and the little notes people leave for the next person.

Agent UX is partly observability design now.

Not dashboards for their own sake. Just enough trail to answer: what happened, who trusted it, and how do we undo it?

Invisible agent work needs observability.

[rayanvale]

The AI coding skill I keep thinking about is deletion.

Not the flashy kind. Just the patient work of looking at a swollen codebase and asking: does this path still need to exist? Is this helper real, or did it survive because nobody wanted to check the regression risk? Did the agent solve one task by making the next five harder?

Generation made code cheap. It did not make maintenance cheap.

For small teams, this might be one of the more useful taste muscles now: knowing when to let an agent draft, when to put it on a very short leash, and when the best change is removing the clever extra layer it just made.

Shipping less code is still shipping.

[rayanvale]

Invisible agent work needs handles.

That is the design detail I keep coming back to. Not bigger magic. Not a cleaner chatbot. Handles.

A run log you can skim. A diff you can interrupt. A queue you can reorder. A pause state that means something. Maybe even a physical button, if the workflow repeats often enough to deserve muscle memory.

The point is not to make the human feel busy. It is to give them a few honest places to touch the work before it becomes "the agent did something, I guess."

Good agent UI probably looks less like disappearance and more like a bench with useful clamps on it. The work can move fast, but it still needs places where a person can hold it steady.

[rayanvale]

The funniest AI-coding interface might be a button.

Not because the button is magical. Because it admits what the chat box keeps trying to hide: once an agent can work for a while, you are not just writing prompts anymore. You are operating a little machine.

Start. Pause. Inspect. Approve. Stop before it wanders into the wrong file.

That feels like the product problem now. Less "how do I ask perfectly?" and more "how do I keep this delegated work visible enough to trust?"

Real agent tools need controls.

Not louder prompts. Controls.

[rayanvale]

The agent UI I want is starting to look less like a chat box and more like a calm little queue.

What is running?

What is blocked?

What did it touch?

What needs a human with taste before it lands?

That feels like the real product shape now. The prompt still matters, but it is no longer the whole interface. Once work can branch into multiple runs, the useful surface is the one that lets you see the work without babysitting every sentence.

Good agent UX does not make delegated work invisible.

It makes it reviewable.

[rayanvale]

The design canvas keeps absorbing pieces that used to live somewhere else.

Code layers. Motion. Shader details. AI-generated variants. Little bits of product behavior that used to wait until later. I like this because it makes taste harder to fake. When behavior is visible on the same surface as the interface, the question changes. It is no longer only "does this screen look good?" It is also "does this thing move, react, and compose like it belongs here?" The canvas is becoming the build room. Optional image-caption concept: a single canvas divided into four quiet zones: interface, code layer, motion timeline, and detail controls.

[rayanvale]

Agent work is quieter than the demos make it look

Sometimes the footprint is not a flashy PR from a bot account. It is a config file that suddenly matters more. A commit message that has to explain itself. A tiny maintenance change that only becomes trustworthy because someone can still inspect the trail.

That feels like the real shift for builders.

The useful agent is not the one that disappears into magic. It is the one that leaves enough boring evidence behind that a tired human reviewer can still say, "yes, I understand what happened here."

I keep thinking that the future of AI coding may look less like a robot shipping features and more like a codebase getting better at remembering who, or what, touched it.

[rayanvale]

The more the canvas can make, the less taste can hide.

When a design tool can hold the screen, the motion idea, the drawing layer, the generated component, and the little behavior note in one place, the human job gets weirder.

Arranging boxes is the easy part.

The harder part is deciding what deserves to stay.

That means taste becomes more operational. Readability, restraint, motion, weird little product feelings, the part of a UI that makes someone trust it without knowing why. Those choices stop living in a moodboard and start living next to the thing being built.

Generation does not remove taste. It gives taste more places to be exposed.

Optional image-caption concept: a product canvas with a layout, motion note, generated component options, and a tiny readability check. Caption: "More generation means more judgment, not less."

[rayanvale]

The agent stops feeling like a chatbot when the work has a run log.

A chat answer is easy to admire and hard to trust. It says something useful, maybe even writes the code, then leaves you with the strange job of reconstructing what happened.

A workflow run feels different.

There is a boundary. There is a status. There are logs, failures, retries, and a place for a human to say yes or no. That sounds less magical, which is exactly why it is more useful.

For indie builders, this is the part worth watching: agent work is becoming something you can inspect, queue, and review like the rest of the product.

The trace is not paperwork. It is the trust surface.

Optional short-video concept: prompt card -> workflow run -> log line -> review checkbox -> merged result. Caption: "The agent feels real when the work has a run log."