Vibes, Velocity, and Validation: The Real Value of Prototyping with AI

From Prompt to Product: AI Prototyping Workflows for B2B Builders

There’s a new tempo emerging in product development - and if you’re still stuck in the quarterly release cycle or scoping documents with 14 review steps, you’re missing it. The cost of building has collapsed, but more importantly, so has the cost of learning.

This post is about how I’m using AI tools not just to ship faster, but to validate smarter. Especially in B2B, where “signal” is the product and prototyping should be your competitive edge.

The AI Prototyping Workflow That’s Rewriting Product Velocity

Let’s say I want to build a simple tool that scores website visitors based on engagement depth. Maybe I want to know which companies are spending time in implementation guides or pricing pages, not just who’s clicking a display ad.

Here’s how I get from idea to working prototype using AI tools, without dragging engineering into the weeds:

• I start in GPT: I break the problem down and map logic. “Build a scoring model that assigns 0–100 attention points based on time on page, scroll %, and page category.” GPT gives me a plan.

• Then I move to Cursor; my AI-powered IDE. Cursor writes the Python or JS for each part of the prototype. I don’t need to memorize syntax; I need to focus on the logic.

• Next stop: Replit; I paste in my code and run it live. I get a hosted version, console logs, and the chance to test inputs immediately. Replit lets me make fast visual changes as I see my creation come to life

• If it’s working, I push it to GitHub, for version control and handoff to engineers once I’m ready to harden the build.

That’s the core loop. Idea → prompt → code → preview → share.

It’s not just faster, it’s fun. And fun in product is a leading indicator of good outcomes.

When to Hand Off and How to Not Waste Your Engineers’ Time

At some point, the prototype crosses the line between “useful test” and “real thing.”

Often we never get to this stage. If for example my Replit tool has a single use case linked to a client’s own peculiarities, and the Replit tool works for the job in hand, it can live in the incubator

The wider objective though is to build live products which will graduate. That’s when I package it up for engineering.

But instead of dropping a vibe-driven mess in their lap, I:

• Include my original GPT/Cursor prompts, so they understand intent.

• Add inline comments and assumptions directly in the code.

• Highlight which parts are scaffolding vs logic that should persist.

• Flag any missing edge cases or unvalidated data flows.

This is miles better than handing over a Notion doc and hoping they get it.

Let’s Talk About Vibe (And Its Limits)

We’re entering what I call the “vibe era of product.” I’f there’s any teams getting liberated by these tools it’s the product ones

You can go from nothing to something that looks plausible shockingly fast. But it’s easy to get caught in the illusion that your prototype is production-ready.

Subreddits like the Replit ones are filled with complaints. I got 80% but couldn’t get past the last mile. Or my app failed when I launched it as a B2B SaaS. Heaven help us, people can’t see the wood for the trees and these tools for what they are. They don’t belong in customer hands, they need a boat load of hardening before that stage

Vibe helps you:

• Explore a new idea

• Visualise a workflow

• Share an internal demo

• Validate early interest

• Stress test spec with the end internal user

But vibe fails when:

• You skip edge cases

• You hardcode assumptions

• You confuse “runs” with “ready”

• You forget compliance, security, auth, state, or scale

Vibe is a great place to start. It’s a terrible place to ship from.

What I’m Seeing in the Best Product Teams

The smartest companies are integrating AI tooling into both product and engineering workflows. They’re not replacing engineers — they’re accelerating learning loops and reallocating focus.

• Hex lets users co-pilot data exploration with AI.

• Vercel launches API demos with 10-line frontend code.

• Replit builds new features using their own Ghostwriter stack.

• Notion AI ships product experiments inside the UX before hardening them in code.

And from my side, we’re using tools like Matomo, enrichment layers, and FunnelFuel’s own tags to validate signal logic before we build pipelines.

The pattern is clear: prototype like an engineer, test like a strategist.

AI for Signal Builders: What I’m Prototyping Now

I’m particularly interested in small prototypes that help validate new B2B signals. A few ideas I’ve either built or am currently scoping:

• Attention scoring based on page engagement

• Fuzzy-matching tools for resolving conflicting IP/company mappings

• A browser-based ABM scoring assistant — where you paste a LinkedIn profile or company name, and get back a signal score

• Custom Intent models using first party signals

• Custom event extraction from logs

• All kinds of log level data fun

I’ll share one below.

But here’s the punchline: each of these costs me under $50 to prototype. They used to take multiple engineers and a dedicated sprint. That’s why I keep saying the real value here isn’t just velocity — it’s validation.

Sample: Attention Scoring Agent Prototype

Here’s a working Python snippet I tested in Replit. It takes simple Matomo-style session logs and returns a company attention score based on time on page, scroll %, and intent category of the page.

def score_session(session):

score = 0

# Weight: time on page

if session["time_on_page"] > 60:

score += 20

elif session["time_on_page"] > 30:

score += 10

# Weight: scroll depth

if session["scroll_percent"] >= 80:

score += 20

elif session["scroll_percent"] >= 50:

score += 10

# Weight: page category

high_intent_pages = ["pricing", "contact", "api-docs", "security", "implementation-guide"]

if session["page_category"] in high_intent_pages:

score += 30

# Bonus: repeat session or new company user

if session["new_user"] == False:

score += 10

return min(score, 100)

# Example input

session_data = {

"time_on_page": 75,

"scroll_percent": 85,

"page_category": "pricing",

"new_user": False

}

print("Attention Score:", score_session(session_data))

With just this logic and a few mock sessions, I can validate whether the model feels right. From there, I can build a UI or export results into a signal dashboard.

Where Agents Come In

With the latest round of OpenAI updates, I’m also exploring the value of persistent Agents - especially for internal use.

I’m considering agents for things like:

• Automated QA on signals pipelines — checking for broken enrichments, expired IP ranges, or format mismatches

• Summarising signal performance — generating a weekly Slack post with the best-performing HVA combinations

• Scoring model validator — feeding in raw behavior data and getting back a confidence score + error log

• PRD spec buddy with persistent memory

The power here is not in replacing team members. It’s in creating a shared baseline of intelligence. Agents that remember what success looks like, that hold the model logic, and that can answer questions consistently across the org.

Once GPT Agents can natively browse, run tools, and fetch live data (as announced), this gets even more interesting for signal-based systems. GPT 5 is on its way and I expect a whole new world of opportunity with it

Final Thought: Vibe is the New MVP

In this new world, speed to validation beats speed to market. You can now prove signal value before you ever touch your core stack. That’s a gift.

But with that comes a new discipline, a focus on:

• Modularity

• Strategic handoff

• Realistic data

• Bias toward outcomes, not aesthetics

Prototyping with AI isn’t just a technical shortcut. It’s a strategic unlock.

And the smartest builders in B2B? They’re using it to test signals, rewrite scoring logic, and ship intelligence — not just interfaces.