I’ve been thinking a lot about how to make software creation easier—more intuitive, more efficient, more aligned with how people actually work. That’s what drives Gadlet. But if our goal is to empower non-technical users (and businesses) to build software, could the chat box be holding us back?

🤔 Why Chat Might Be the Wrong Default

Chat UIs mimic conversations—easy enough for quick questions. But building software is not just chit-chat. Gadlet’s users want intent-driven creation, not dialogue. Chat interfaces:

  • Create illusions of memory—users expect continuity even when the model doesn’t retain state.
  • Accumulate context that becomes irrelevant or costly after each prompt, yet continues ballooning token costs.
  • Encourage exploration, but often lack structure or composability for real build flows.

We risk turning software building into talking to a bot—not guiding a tool.

💡 UX Alternatives That Align with Gadlet’s Vision

How can we shift from chat to building workflows that respect user intent, iteration, and cost—central principles at Gadlet?

1. Prompt‑Sequence Decks

Inspired by a prototype idea:

  • Users layout a deck of high-level goal cards (“Build calorie calculator → Use SQLite → Add report feature”).
  • Cards are ordered, editable, and composable.
  • A single run generates the app; edits re-run parts or the full sequence.

2. Canvas + Node Workflow

Borrowing from Databutton & research tools:

  • Each node is a task (“generate UI scaffold”, “add auth”).
  • Users can preview outputs, tweak prompts, and isolate reruns.
  • Costs stay contained per node, and trust grows by visible outputs—not buried chat.

3. Inline Prompts in Code

In Gadlet’s interface, users input plain-English specs once; then:

  • The code appears in an editable canvas with inline prompt blocks guiding generation ("// auth here").
  • Each block runs separately.
  • Encourages direct manipulation, not second-party chat.

4. UI Design Commenting -paradigm

Aligned with the way teams work with design tools (like Figma):

  • The preview UI allows the user to add comments to any element.
  • The comment immediately triggers a change in code
  • Eventually the user sees that the comment has been dealt with and can either approve or undo the change

5. Paged Task Interfaces

A clear, slide‑style workflow:

  • Page 1: define objective
  • Page 2: scaffold UI
  • Page 3: scaffold backend
  • Page 4: add auth/tests Each page has prompts, live output preview, and rerun capability. No scroll backlog—just step-by-step building.

Where This Fits in Gadlet’s Mission

At Gadlet, we’re trying to remove the complexity of development so people can focus on what they want to achieve. Non-chat UIs:

  • Highlight intent-driven flow over conversational noise.
  • Enable reliability and cost-control via scoped runs.
  • Let users manipulate building blocks, not chase chat threads.

In essence, it’s about capturing and refining intent, not replaying conversations. We want tools that let users build, not just talk.

🎯 What’s the Ideal Path Forward?

My current personal favourite is the UI Design Command -paradigm. It would at least be very specific, visual and probably natural for a non-technical person.

What’s yours?

What is your take on the challenge of a UI without chat for a non-technical user?

We’re Still Figuring It Out

None of these replace all use-cases of chat—that’s a natural fit for exploration and brainstorming. But for the task of building software, a structured, modular UX is more powerful and aligned with what we want Gadlet to become.

So: ditch perpetual chat logs, lean into structured intents, previews, decks, comments.

I’d love to hear your thoughts—what if the AI didn’t chat at all? What if you built—step by step—working apps with instant previews and clear iterations? Could that feel more like building and less like chatting?