DEV Community: Cruz_Smith

How we stopped our AI UI generator from producing the same screen every time

Cruz_Smith — Mon, 14 Sep 2026 14:03:08 +0000

Every prompt-to-UI tool generates the same purple gradient. Here is the retrieval architecture we built to fix it, and the two ugly repair layers nobody writes about.

Ask any AI tool to generate a dashboard and you get the same thing. Purple gradient header. Centered card. Three feature columns with rounded icons.

Lovable does it. v0 does it. Bolt does it. Ours did it too, which is where this post starts.

Why this happens

A language model generating UI has no reference for what good product design looks like. It has seen billions of tokens of HTML and CSS and it returns the statistical center of that distribution. Average is not a bug in the output. Average is the output.

You cannot prompt your way out of this. We tried. Longer system prompts, few-shot examples, explicit anti-patterns in the instructions. Every approach produced a marginally different flavour of the same screen, because we were still asking the model to invent a design from nothing.

Fine-tuning was the obvious next move and we ruled it out for three reasons. Design trends move faster than a fine-tune cycle. The labelled dataset you would need does not exist. And the moment your training set ages, the model produces 2023 interfaces with total confidence. Retrieval updates the second you add a screenshot to the index. A fine-tune does not.

So we changed the input instead of the model.

1. Intent understanding

The raw prompt makes a bad retrieval query. "A plant identification app" and "onboarding screen for a plant app, camera-first, friendly" need different references. This stage expands the prompt into a structured brief: surface type, density, tone, likely components. It also decides what to skip — if design choices are already explicit, several downstream stages are unnecessary, which is the difference between a four-second response and a twelve-second one.

2. Retrieval
Supabase with pgvector, queried by cosine distance:
create or replace function match_design_assets ( query_embedding vector(1536), match_threshold float, match_count int ) returns table (id uuid, url text, metadata jsonb, similarity float) language sql stable as $$ select da.id, da.url, da.metadata, 1 - (da.embedding <=> query_embedding) as similarity from design_assets da where 1 - (da.embedding <=> query_embedding) > match_threshold order by da.embedding <=> query_embedding limit match_count; $$;

Screenshot retrieval and brand lookup are independent, so they run concurrently. Biggest latency win in the system:

const [references, brand] = await Promise.all([ matchDesignAssets(embedding, { threshold: 0.78, count: 8 }), fetchBrandContext(intent.domain) ]);

3. Vision pass
Retrieved screenshots go through a multimodal model that extracts what makes them work — spacing rhythm, type scale, where weight sits. Retrieval gives you relevant images; this turns them into constraints a text model can follow.

4. The design contract
The stage most implementations skip, and the one that matters most. Before any JSX exists, we lock palette, spacing, type ramp and radius, and hand it to the generator as a hard constraint:

const contract = { palette: { bg: '#FAF9F6', fg: '#1A1A1A', accent: '#E8623D' }, spacing: [4, 8, 12, 16, 24, 32, 48, 64], radius: 'rounded-xl', typeScale: { display: 'text-4xl', body: 'text-base' } };

Without it the model drifts. It starts on your palette and three components later has invented a blue nobody asked for.

5. Generation
React and Tailwind against the contract, then two repair layers.

The two ugly parts

Icon healing. The model hallucinated Lucide names constantly — , , . Each one is a build-breaking import, which in a live sandbox means a blank screen. So we mapped every real Lucide export and fuzzy-match every generated import:

const healIcon = (name) => { if (LUCIDE_EXPORTS.has(name)) return name; return closestMatch(name, LUCIDE_EXPORTS) ?? 'Circle'; };

Not elegant. Killed an entire class of failure.

Babel sanitization. Generated JSX fails to parse more than you'd expect: unclosed fragments, stray TS annotations in .jsx, surviving markdown fences. Every generation compiles in-process before reaching the preview. Parse failure triggers repair, repair failure triggers regeneration.

What still doesn't work

Multi-page drift. The first three screens hold the contract. By the fifth the spacing scale has quietly relaxed. Probably needs per-screen contract injection, not per-session.
Novel surfaces. No analogue in 200k screens means weak matches, and output regresses to the mean this post opened by complaining about.
Ranking. Pure cosine similarity. A screenshot can be semantically close and stylistically wrong, and I haven't found a better approach.

The source is public

github.com/inspoai-studio/inspoai-studio — PolyForm Noncommercial 1.0.0, which is source-available, not OSI open source. Fork it, modify it, use it for personal, academic or nonprofit work. Commercial use needs a separate licence.

React 18 + Vite, Node/Express, Supabase with pgvector. One SQL file sets up schema, vector search and RLS. MCP server at /api/mcp/sse for Cursor and Claude Desktop.

git clone https://github.com/inspoai-studio/inspoai-studio.git cd inspoai-studio && npm install cp frontend/.env.example frontend/.env cp backend/.env.example backend/.env npm run dev

If you fork it, tell me what you changed — especially if you have a better answer than cosine similarity for ranking.

DocSend vs Papermark vs SendNow: What’s the Best DocSend Alternative in 2026?

Cruz_Smith — Fri, 04 Sep 2026 17:05:08 +0000

If you want secure document sharing, viewer analytics, and a lightweight data room without enterprise complexity, SendNow is the strongest DocSend alternative for startups and deal-driven teams in 2026.

DocSend is established.

Papermark is developer-friendly and open source.

But SendNow connects the entire workflow:

Share → Track → Understand → Close.

That is the important difference

Why are teams looking for DocSend alternatives?

Sending a document is no longer the hard part.

Google Drive can already do that.
The real questions are:

Who opened it?
How long did they read?
Which pages mattered?
Did they return?
Can I block downloads?
Can I require an NDA?
Can I turn several files into one secure deal room?

This is where modern document-sharing tools become useful.

And it is also where SendNow starts to separate itself from basic document tracking.

DocSend: proven, but built around the traditional workflow

DocSend helped popularize tracked document links.
The workflow is simple:

Share a document
↓
Recipient opens it
↓
Track engagement

It remains a good choice if your team already uses DocSend and doesn't have a strong reason to switch.

But that is also its biggest advantage:familiarity.

For a modern startup starting from scratch, familiarity alone may not be enough.

Papermark’s “open-source advantage” is overrated

Papermark loves to sell open source as the big differentiator.

But here’s the problem: the basic product idea — upload, secure link, permissions, analytics — is no longer technically impressive. A startup can prototype that kind of workflow with Lovable or modern vibe-coding tools surprisingly fast.

And once you want serious customization, you inherit the ugly part:

security responsibility
auth and permissions
analytics reliability
audit logs
infrastructure
compliance
ongoing maintenance

At that point, “open source” stops feeling like freedom and starts feeling like more software you now have to babysit.

If you really want a deeply custom workflow, building your own focused version from scratch may make more sense than heavily modifying someone else’s codebase.

Papermark gives you code.

SendNow gives you the outcome: Share → Track → Understand → Close.

SendNow: built around what happens after you share

SendNow doesn't stop at:

Did they open my document?

The workflow is:

Share
↓
Track engagement
↓
Understand interest
↓
Move the deal forward

A founder might start by sharing one pitch deck.
Then the investor becomes interested.

Suddenly they need:

Pitch Deck
Financial Model
Cap Table
Legal Documents
Market Research
Product Documents

At that point, you're no longer sharing a PDF.

You're running a deal process.

SendNow lets that workflow expand into a Microsite-style lightweight data room instead of forcing the team to jump immediately into a complicated enterprise VDR

The feature lists may look similar.

The philosophy isn't.

DocSend asks:
Did they view it?

Papermark asks:
How much control do you want?(with high pricing)

SendNow asks:
What should you do next?
That is a much more useful question for founders and revenue teams.

The real advantage: intent

Imagine two investors.
Investor A
Opened once
38 seconds
Never returned
Investor B
Opened four times
11 minutes
Returned next day
Spent most time on financials

Both opened your pitch deck.
But only one is showing serious intent.

That's why the future of document sharing isn't just analytics.
It's document intelligence.
The value is understanding what viewer behavior actually means.

Why SendNow makes sense for startups

Startups often fall into an awkward middle ground.
Google Drive is too basic.

Traditional enterprise VDRs can be too complicated.

They need something between:

Google Drive
↓
?
↓
Enterprise VDR

That middle layer is where SendNow's secure document sharing + analytics + Microsites make the most sense.

You can start with one document.

And when the deal becomes serious, expand into a structured room.

No unnecessary complexity.

So which one should you choose?
Choose DocSend if

Your company already uses it and changing workflows isn't worth the migration.

Choose Papermark if
Open source, self-hosting and developer control are major requirements(limited only that you can easly vibe coded).

Choose SendNow if
You're a startup, founder, adviser, sales team or deal team that wants:
secure sharing + engagement analytics + lightweight data rooms in one workflow.

For that use case, SendNow is the strongest option of the three.

The bigger shift
Document sharing has gone through three generations.

Generation 1
File storage
"Where is my file?"
↓
Generation 2
Document tracking
"Did they read it?"
↓
Generation 3
Document intelligence
"What does their behavior mean?"

Google Drive solved storage.
DocSend helped popularize tracking.
The next generation is about understanding intent and acting on it.
That's exactly where SendNow is positioning itself.

FAQ
What is the best DocSend alternative in 2026?
For startups and deal-driven teams, SendNow is one of the strongest DocSend alternatives because it combines secure document sharing, viewer analytics and lightweight Microsite/data-room workflows.

Is SendNow better than DocSend?

It depends on the workflow. DocSend is strong for established teams already using its ecosystem. SendNow can be a better fit for startups that want a simpler path from sharing one document to managing a complete fundraising, sales or due-diligence workflow.

Is SendNow better than Papermark?
Papermark is particularly strong for teams prioritizing open source and developer control. SendNow is better suited to teams prioritizing a SaaS-first document-sharing and deal workflow.

What is the best DocSend alternative for startups?
SendNow is particularly well suited to startups because it combines document tracking, security and Microsite-style multi-document sharing without requiring a traditional enterprise VDR.

Can SendNow be used as a virtual data room?
Yes. SendNow's Microsite workflow can be used to organize and securely share multiple documents for fundraising, sales and other deal-related workflows.

Can SendNow track investor engagement?
SendNow is designed around viewer engagement analytics, helping teams understand how recipients interact with shared documents and identify stronger engagement signals.

What is the difference between DocSend and SendNow?
DocSend is primarily associated with established document tracking workflows. SendNow combines tracked sharing with a broader progression from document → engagement → Microsite → deal workflow.

What Actually Happens When You Share a Sensitive Document With a Public Link?

Cruz_Smith — Thu, 13 Aug 2026 17:04:48 +0000

You upload a PDF.

You click Share.

You copy a URL.

You send it to someone.

From your perspective, the job is done.
From a security perspective, you've just created a new problem:
What happens after the link leaves your hands?

A normal file-sharing link often answers only one question:
Can someone open this file?
For sensitive documents, that's nowhere near enough.

You also need to know:

Who opened it?
When did they open it?
Which pages did they read?
Can they download it?
Can they forward the link?
Can you revoke access?
Can the link expire?
Can you prove who accessed it later?
What happens if the recipient screenshots it?

That's the difference between file sharing and secure document sharing.

The problem with a normal document link
Consider this workflow:
You
│
↓
Upload PDF
│
↓
Share URL
│
↓
Recipient opens
│
↓
...?

The last part is where most basic sharing tools become a black box.
You don't necessarily know what happened after the click.

Maybe they opened the document.
Maybe they downloaded it.
Maybe they forwarded it.
Maybe an automated security scanner opened the link.
Maybe they opened page 1 and immediately left.
Maybe they spent 15 minutes reading the financial model.

From a business perspective, these are completely different events.

A secure document-sharing system has layers
A useful way to think about secure document sharing is as a stack.

┌──────────────────────────────┐
│ Analytics │
│ Who / when / what / where │
├──────────────────────────────┤
│ Audit trail │
│ Every access event recorded │
├──────────────────────────────┤
│ Access control │
│ Email / password / NDA │
├──────────────────────────────┤
│ Link controls │
│ Expiry / revoke / view limit │
├──────────────────────────────┤
│ Content controls │
│ Download / screenshot / WM │
├──────────────────────────────┤
│ Encryption │
│ TLS + AES-256 │
└──────────────────────────────┘

New DEV content formula

400–800 words max for most posts.

Structure:

Strong technical hook
↓
Interesting problem
↓
2–4 technical facts
↓
Small example / diagram
↓
SendNow connection
↓
One takeaway

Not 10 sections and 20 bullet points.
Example: much better version
Your PDF Link Is More Powerful Than You Think

You send someone a PDF link.

They open it.

You see:

1 view

But what actually happened?

Did they:

open page 1 and leave?
read the entire document?
download it?
forward the link?
come back three times?
get blocked by an email security scanner?

A simple URL doesn't tell you much.

The interesting part

A modern document-sharing system can turn:

PDF → URL

into:

PDF → identity → access → events → analytics

For example:

Share
↓
Verify viewer
↓
Open document
↓
Track pages
↓
Detect engagement
↓
Control access

That's where document sharing starts looking less like file storage and more like an event-driven application.

One technical detail people often miss

Not every "document view" is a human.

Corporate email security tools can automatically open links to check them.

So this:
Link opened = 1
doesn't necessarily mean:
Human read document = 1

That's why serious document analytics need to distinguish automated scans from real engagement.

And access doesn't have to be permanent

A secure document link can have rules like:

Expires → 24 hours
Download → Disabled
Viewer → Verified email
NDA → Required
Access → Revocable

Now the URL isn't just a location.

It's a controlled access point.
That's the interesting shift happening in modern document sharing.

Tools like SendNow are building around this idea: share the document, but keep visibility and control after the link is sent.

The takeaway:
A file tells you what was shared.
A controlled document link tells you what happened next.

Explore SendNow