I’m not a manager or a team lead, and I’ve never been good at breaking down instructions. I don’t naturally think in flowcharts or task trees, and my design work usually starts after decisions are already made—adding structure, tone, and clarity to something that exists but isn’t finished yet.
So when I first encountered a node-based interface, I assumed it probably wasn’t meant for someone like me.
The kind of UI I thought this was for
Node-based tools often feel designed for people who are comfortable thinking in systems—people who can decompose goals into steps and conditions without much friction. That has never been my strength.
Because of that, the interface felt intimidating at first. Powerful, but distant. Useful, maybe, but for someone else.
Node-based interfaces look free — but they aren’t
At a glance, node-based UIs look open. You can place things anywhere, connect almost anything, and follow no single “correct” path.
But once you start using them, you notice that every node quietly asks a question: what are you deciding here, what is still undefined, and where does this flow stop or branch?
The interface doesn’t force answers—it just refuses to hide the gaps. What feels like freedom turns out to be a kind of constraint that makes ambiguity visible.
What changed for me
The interface didn’t tell me what to think or block experimentation. I could try things, undo them, and rearrange everything.
But each connection made it harder to pretend that everything was already decided. It doesn’t remove options; it removes vagueness. You can experiment freely, but you can’t stay unclear forever.
That shift—seeing my own uncertainty laid out on the canvas—changed how I worked.
What I actually built first
I started with something small: a simple flow to review UI text and suggest alternatives. No branching logic, no complex setup—just a few nodes.
Even there, the canvas showed me where I hadn’t thought things through. Where do I want feedback, and where do I want judgment? What am I assuming the AI already understands?
It wasn’t solving the problem for me. It was showing me the gaps.
Design as structure
As a designer, I often arrive after the structure is set. My role is to give shape and coherence to decisions made elsewhere.
That's why I cared about how the nodes in Giselle looked and felt. I wanted them to feel light, maybe even glow a little. I once wanted them to turn into stars when you zoomed in.
That idea didn't survive. Not because it wasn't meaningful, but because it wasn't a priority in time for the release.
Still, even within those limits, the interface could act as structure—not decoration, but support for unfinished thinking.
Why this might still work for someone like me
I’m still not great at breaking problems into clean hierarchies. But with a small number of prompts and simple settings, I can see my ideas start to move.
Not because the tool thinks for me, but because it shows me where I haven’t thought yet.
If you’ve ever felt that tools like this were built for someone else, this one might be worth a look.
We made Giselle open source so that anyone could try this way of thinking—with structure instead of against it—not after ideas are finished, but while they’re still forming.
If you’re curious:
- Try Giselle → https://giselles.ai
- See how it works → https://github.com/giselles-ai/giselle
- Support us on Product Hunt → https://www.producthunt.com/products/giselle