Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Created an agent skill called “Visual Explainer” + set of complementary slash commands aimed to reduce my cognitive debt so the agent can explain complex things as rich HTML pages. The skill includes reference templates and a CSS pattern library so output stays consistently well-designed. Much easier for me...

1,458,847 Aufrufe • vor 7 Monaten •via X (Twitter)

34 Kommentare

Profilbild von gootecks
gootecksvor 6 Monaten

you're a wizard, WOW and here I was thinking I had gotten some decent mermaid output with a couple of skills put together 🤣 no joke, visual explainer puts the other mermaid skills to shame thank you!!! 🙏

Profilbild von Leon Ho
Leon Hovor 7 Monaten

Smart move. I noticed the same thing building agent skills - once output format is standardized, you stop reading and start scanning. That's where the cognitive savings actually live, not in the answer itself but in how fast your brain can parse it.

Profilbild von Chris Sonnier
Chris Sonniervor 6 Monaten

@GregThatIsAll This is why I built because I got tired of reading markdown files and there is so much more depth to html files.

Profilbild von Fran Arant
Fran Arantvor 6 Monaten

That looks very cool! I have been having it make text adventure "memory palaces" 😅

Profilbild von OneManSaas
OneManSaasvor 6 Monaten

The CSS pattern library is clutch. I built similar templates for my SaaS docs and it cut explanation time by 60%. Nothing worse than rebuilding the same visual structure every time you need to break down a complex workflow.

Profilbild von neonwatty
neonwattyvor 6 Monaten

At first glance, I thought you were outputting code generation to HTML, but the usage in the readme clarifies usage for tables, charts, etc. Very nice.

Profilbild von Manuel Odendahl
Manuel Odendahlvor 7 Monaten

Been playing with that idea (and similar ideas to the other extension you have with the feedback widgets). Also playing with generating PDF forms to upload to my tablet so I can check things off away from the computer. Didn't get around to cleaning them up since just annotating my documents by hand is currently good enough. Love your stuff.

Profilbild von silv
silvvor 6 Monaten

needed this, thank you

Profilbild von fero
ferovor 7 Monaten

just use mermaid diagrams, no?

Profilbild von Roberto Mello
Roberto Mellovor 7 Monaten

How’s it different from anthropic’s playground plugin?

Profilbild von shpetim
shpetimvor 7 Monaten

This is pretty neat and good effort. But I think this level of "instruction" will overload the AI. Too much wasted on context having to follow those prompts and templates. I prefer to give the AI a loaded gun :)

Profilbild von Bill Wheelock
Bill Wheelockvor 6 Monaten

Yes! This! I've been doing this for awhile, but this is far more formal. A lot of times when discussing a spec or new task with my PM agent, I'll ask for an HTML with dynamic elements to visualize it. Helps if you tell it to add some rizz.

Profilbild von J. Mario Meissner
J. Mario Meissnervor 6 Monaten

This is genuinely incredible, bookmarked 📕 I wouldn’t be surprised if something like this gets integrated into the CLIs themselves soon

Profilbild von Marchen
Marchenvor 7 Monaten

the css pattern library is a nice touch - keeps output consistent without having to specify styling every time

Profilbild von jay
jayvor 6 Monaten

This looks really cool, great job and thanks for sharing 👌🏻

Profilbild von Kelly Sommers
Kelly Sommersvor 6 Monaten

This is fire and thanks so much for sharing. I’m doing something kind of similar but not as good as you Every new feature, optimization investigation, or learning I ask Codex to write me a readme markdowns with high level with links to individual markdown docs with deep dives

Profilbild von Chris Butler
Chris Butlervor 6 Monaten

This is great. I've been doing this on my "explanation" markdown files lately, never got around to writing a skill for it. Will give it a rip!

Profilbild von Vasilije
Vasilijevor 6 Monaten

Rich HTML explanations instead of terminal walls of text. That's a quality of life unlock.

Profilbild von Sheldon ⚡ Hull
Sheldon ⚡ Hullvor 6 Monaten

I've been using anthropic as playground skill and loving it. This reminds me of this but a different feel. I'm definitely gonna give it a try. Nice work.

Profilbild von Tomash Devenishek
Tomash Devenishekvor 6 Monaten

Boss!

Profilbild von KShivendu 🌁
KShivendu 🌁vor 2 Monaten

Looks promising. I've installed it. Thanks!

Profilbild von Cobalt ☥☥
Cobalt ☥☥vor 7 Monaten

we converged on making similar tooling within the same ~20 hr period lol. nice

Profilbild von Jesse
Jessevor 6 Monaten

Brilliant. Thanks 🙏

Profilbild von Maxime Steinhausser
Maxime Steinhausservor 6 Monaten

Game changer! Thanks 💖 🙏

Profilbild von Josie Kins
Josie Kinsvor 4 Monaten

immediately installed and found it much better than the diagrams i've asked codex to produce in the past, thanks!

Profilbild von Shake®
Shake®vor 5 Monaten

this is awesome man, ggz

Profilbild von Julius Gonzalez
Julius Gonzalezvor 6 Monaten

@amorriscode potential core product feature 👀

Profilbild von Saushank.eth
Saushank.ethvor 6 Monaten

@AdamBoudj

Profilbild von Lavine
Lavinevor 18 Tagen

pi-deep-research v0.3.0: pi install npm:pi-deep-research Pair it with @nicopreme's Visual Explainer and the results come back as visual reports instead of a wall of text. The search tool is now a hot-pluggable provider chain. Tavily + Brave built in.

Profilbild von Lautaro.x
Lautaro.xvor 6 Monaten

Very cool

Profilbild von Kelly Sommers
Kelly Sommersvor 6 Monaten

Then I tell it in every deep dive use any mermaid diagrams it thinks would be helpful to teach me topology, interactions, concurrency and sequences. So it’ll generate me flow diagrams or sequence diagrams etc

Profilbild von Noel Smith
Noel Smithvor 6 Monaten

Cool

Profilbild von Hariharan S
Hariharan Svor 6 Monaten

I built something similar but not as beautiful looking as yours. All mods to the mermaid diagrams are so nice. I might steal some.

Profilbild von darshil
darshilvor 6 Monaten

just use obsidian

Ähnliche Videos

Introducing /visual-plan - a skill to generate rich, visual plans for Claude Code and Codex. Plan mode in Claude Code is incredible. But I always find my eyes glazing over when it gives me this huge markdown essay in my terminal. I found I can make much better visual plans with reusable components. So I made a skill called `/visual-plan`. It generates plans as MDX with visual, interactive components. Diagrams, interactive API specs, schema design changes, annotated code, and even pan and zoomable wireframes. So for any UI work, you can look at a wireframe first, comment on it, iterate, and then have the agent work. I’ve found this to be a much more intuitive interface for reasoning about what the agent is doing. It’s somewhat inspired by that popular post about how HTML is better than Markdown. But HTML can be slow and verbose to write. And it doesn’t look good checked into a repo. This has really made me feel like humans and engineering are entering a new abstraction phase, where we reason about things at the plan level. As long as the plan is good, agents are getting more and more reliable at executing on it. Almost to the degree that we trust the C compiler to compile to assembly reliably. Plans are the new intermediate representation. I also made a skill for the reverse of this, called `/visual-recap`. After the agent works, it gives you a recap of everything it did. Same idea: wireframes, interactive API specs and diffs, schemas, annotated code, etc. So now when you’re reviewing what the agent did for you, or looking at a pull request of somebody else’s code, you can see a visual recap instead of just reading a wall of text. It’s all free and open source. You can find it on my GitHub. Will link to it in the reply because we all know how dumb these algorithms are with links.

Steve (Builder.io)

126,165 Aufrufe • vor 3 Monaten

AG-UI makes building agentic applications dramatically easier. Here's how it works. This is a model for a simple chatbot: User → LLM → Response But interactive agents that render UI, pause for approvals, and ask users for input need a much more complex model. When building these agents, a response from the LLM will include a series of state changes as the agent runs: • Agent started a task • Agent called a tool • Agent updated its state • Agent streams these tokens • Agent is waiting on a human • Agent is resuming the task The Agent-User Interaction Protocol (AG-UI) treats the LLM response as a stream of events rather than a text endpoint. In practice, here is what you get as an agent runs: 1. Lifecycle events so your UI knows where the agent is. 2. Text messages that stream tokens. 3. Tool calls so your UI can prefill a form with any required arguments. 4. State updates that keep your UI in sync with the agent. 5. Special events for human approvals, rich media, and custom needs. All of these events travel over standard transports (SSE, WebSockets, or plain HTTP) as JSON. As a result, you can build a frontend that stays in sync with the agent's progress without having to invent a custom process to make this happen. For example, building a human-in-the-loop workflow becomes an off-the-shelf component you can integrate rather than build from scratch. CopilotKit🪁 is the creator of AG-UI, and you can use it when building frontend applications pretty much anywhere: • React • Angular • Vue • React Native • Slack • Teams • Discord • WhatsApp • Telegram Here is the link for you to check it out: Thanks to the CopilotKit team for partnering with me on this post.

Santiago

17,438 Aufrufe • vor 2 Monaten

When I’m trying to improve the user experience of my applications, one of the most valuable things is being able to see an entire user flow as a storyboard. Not just one screen or screenshot at a time. This is something I love using the `/visual-plan` skill for. You can describe any flow you want, and the agent will look through your code and wireframe out a storyboard of what the flow looks like. Then you can visualize the steps in a simplified way and spot areas to improve. Recently, I found that in certain flows we were still asking for organizations, even though I thought I had gotten rid of that and made it automatic. A quick storyboard let me see all the different code paths in a simple, visual, intuitive way. Spot the areas of the flow I didn’t want. And have the agent fix it. Sign up, onboarding, and setup flows are usually some of the most important experiences in your app. And usually the least looked at. Especially because it can be hard to reproduce every flow, for every situation, for every user type, feature flag, or whatever else you have. The `/visual-plan` skill lets you visualize any part of your code. Either to understand the current state, plan out a new state, or recap updates that were made. I’m pretty addicted to this skill. I use it for a lot of other things too, so let me know if you want to see videos on those. And of course it’s all open source. You can grab it on my GitHub. I'll link to it in the thread. If you try it, let me know your feedback.

Steve (Builder.io)

148,613 Aufrufe • vor 2 Monaten

What does the reputation model look like for agents? (alpha leak below) And how do we associate the proofs that we have about human beings with the agents who represent them? You may have heard of a process called KYC or Know Your Customer. That's very common with traditional financial applications and services. We have introduced a concept that we call KYA or Know Your Agent, which is a structured way to be able to express what model, how data was used in training, who the deployer is, what entities this agent instance is accountable back to, providing not only provenance but identity of the associated organization or entity. That's also another root of trust that we think about a lot: Enterprises and organizations tied back to things like their domains. To share a little bit of an alpha leak here, a product that we're excited to be rolling out in the next few weeks will allow our enterprise partners to more easily verify and prove the traits and capabilities of their teams as well as their counterparties. On the agent front, that makes it really easy to prove that an agent is acting on behalf of a given business or entity. We've already seen lawsuits where the absence of such technology has been a huge risk, such as with airlines that incorporate ChatGPT wrappers in their support pages. And then those AI enabled interactions end up making up plane tickets that don't exist and those airlines have to honor them. As small of an example as that might be, being able to prove agent accountability also unlocks a huge set of opportunities for use in enterprise for those agent to agent interactions. The Deep Trust Framework that our team has put together that we're excited to be bringing into a friendly SDK form in the next few weeks for some of our partners includes those reputation based capabilities, so how you can basically keep track of the interactions an agent has had, associate all of that to the entity to which they're accountable, and then that creates a sustainable reputation model for these agent to agent Interactions. Source: Billions CEO Evin McMullen evin speaking at House of Chimera Spaces Event Dec 3, 2025

Billions Network

68,503 Aufrufe • vor 9 Monaten