1/ 25
Sign in
Vibecoding 201

Building Production GTM Tools

Evolution from Vibecoding IC work to Agentic Engineering for GTM.

Scott Ewalt · Founder, Cardinal ElementSponsored by
Pavilion AI in GTM School

Go deeper

This deck's own source code. Every claim in the next hour is checkable against it. github.com/skidubb/vibecoding-201

Scroll, or press →
Two screens

Which one runs Monday's retention meeting?

Vote on this screen.

This poll opens during the session.

101 · May 20

Youbuiltaprototypein101.Today,you'llbuildasystem.

A production system means someone depends on it: records that persist, access that is controlled, failures that are handled, behavior that is verified, and an owner with a name.

Trends in AI development

Frontier models require less step-by-step instruction. This continues to change how we prompt and how we guide agents to develop.

Agent capabilityStep-by-step instruction from youOutcome definition, guardrails, verification
What follows is the best of our knowledge - August 6, 2026.

Go deeper

Boris Cherny, who built Claude Code, deleted instructions, plan mode, and prompts release by release and never walked back verification. ycrootaccess.com claude.com/blog

More levels, more devils

Surface area determines how much rigor you owe.

Use one question: can you silently fix this after it is wrong? If the answer is no, the work needs explicit checks and a release gate.

External facing

Evals, release gates, monitoring, and rollback. Repair customer or partner trust.

Whole org

Written rules plus test data. Correct an operating decision and notify users.

My team

Someone else reviews the result. Explain the correction to a small group.

Just me

Eyeball the output. Correct or discard it quietly.

Vibe codingAgentic engineering

Enterprise is a multiplier: procurement and security review add obligations on top of the reach floor.

Sort the work · evolution of Vibecoding

Start with low-stakes individual work. Add verification as reach and consequence grow.

The red boxes are the two failure modes.

Low verification

High verification

High stakes

Danger zone
Lead scores written to CRM, a forecast rollup for the board, automated outbound sequences.

Agentic engineering

Pipeline health scoring, territory and quota models, rep-versus-buyer loss reconciliation.

Low stakes

Vibe coding

A win/loss theme explorer, a one-off QBR chart, a rep's private deal view.

Over-engineered
A full eval suite for one chart, CI for a throwaway pull, a formal spec for a scratch script.

A lead-scoring model and a quota model are both code. The required checks come from consequence, not complexity.

Harness engineering

Beyond prompting. The harness is the system.

The model is only a small part of getting quality outputs. The harness is everything that makes the model useful, constrained, and verifiable.

Coding harness

~90% of the working system

Model

~10%

Generates and reasons. It may be swapped without changing the workflow.

Context

Repository, business rules, examples, and the current state of the work.

Tools

Computer use, APIs, MCP servers, terminal, CRM, warehouse, and browser.

Sandbox

Permissions, approvals, secrets boundaries, and allowed actions.

Verification

Checks, diffs, source rows, screenshots, logs, and human review.

When two products can swap models and still behave like themselves, the durable product is the harness.

Go deeper

Model + harness is the practical architecture in Google's New SDLC paper. The split is a rough heuristic, presented that way by the paper's coauthor. The New SDLC With Vibe Coding addyosmani.com

Choose your working environment

Open or closed: use the harness you already trust.

Both groups will use the same source data and assignment. The comparison is what each harness exposes, automates, and makes easy to verify.

Closed harness

Fast, guided start

Who configures it

The vendor chooses context strategy, tools, deployment, and recovery

Best fit

Fast starts and guided workflows

Open harness

Direct, configurable work

Who configures it

Your team configures context, tools, permissions, deployment, and verification

Best fit

Multi-file work, direct data access, commands, and reusable automation

Choose one now. We will compare correctness, evidence, repeatability, and recovery at the end.

Hands on · 5 minutes

Evaluate one of your projects: is it a prototype, a tool, or a system?

When the timer ends you are holding a verdict, the evidence that decided it, and the first gap to fix — the next exercise builds on those three lines.

Open your coding agent

In the folder of something you have already built. Nothing to evaluate? Download the starter app, unzip it, and that folder is your project.

Download the starter app

Run the evaluation prompt

Copy it from the box below. The agent reads the project and returns a verdict with the evidence that decided it.

Share the verdict

Paste what came back. Share it if you want it in the mix.

The evaluation prompt
Read this project and evaluate it. Do not change anything.

First, classify it as one of the following, by what you can observe in the
code and configuration — never by what the interface promises:

- Prototype: demonstrates the idea with sample or temporary inputs.
- Tool: a defined group reliably completes a real workflow with it.
- System: it runs across teams, data sources, permissions, time, and failure.

Classify by what runs today, not by intent: if the data is sample or synthetic,
or ships inside the code, the verdict is prototype no matter how finished the
interface looks.

Then score it against each item below, answering met, not met, or cannot tell,
with one line of evidence per item — a file, a config entry, or the absence of one:

1. Persistent data — records survive a refresh because they live in a real database.
2. Sign-in — the tool knows who each user is.
3. Enforced authorization — the database decides what each user may see, not the interface.
4. Server-side secrets — no credential values appear anywhere in the code.
5. A tested critical workflow — the main workflow runs under an automated test.
6. Visible error states — every failure says what happened in words.
7. Logs and analytics — every run leaves a record someone can read back.
8. Preview before production — a person promotes each change; saving a file is not shipping.
9. A named owner — someone answers when it breaks, and can roll it back.

Check the verdict against the scores before you answer: mostly unmet items means
prototype, unless a defined group already depends on it in real work — and then
the Evidence line must say who.

Finish with exactly three lines I can paste into a shared box:
Verdict: <prototype | tool | system>
Evidence: <the one observation that decided it>
First gap: <the unmet item that matters most, and the smallest change that would meet it>

Working in Lovable, Base44, Replit, or v0? Paste the same prompt into its chat, on a project you built there — no folder or terminal involved. No agent at all? The kit's no-account path runs the whole hour in a browser.

Time remaining

5:00

…

Agent still thinking when the clock runs out? Take the pre-generated verdict from the kit and keep moving

Hands on starts now

No app, no problem — use this

The shared starting line. Every harness gets the same source data, the same working app, and the same verification baseline.

The starter app

A working GTM dashboard with the CRM data inside it. Download the zip, open the folder, and double-click the standalone file — no server, no account, no key.

Download the app

The CRM data

10,000 deals across 36 columns, dated 4 August 2026, riding inside the starter app. Preserve it as the immutable source.

Open the full CSV

Your coding harness

The open or closed harness you chose. Point it at a copied workspace and keep its connection and evidence visible.

No one starts from a blank page — and no exercise writes back to the source.

Go deeper

The starter app and its CRM data, explained. The app download, a guide to what every column means, and a 200-row sample you can paste straight into any AI assistant. No account needed for any of them. The column guide /kit

The room's verdicts

Is it a prototype, a tool, or a system?

Vote what your agent came back with.

This poll opens during the session.

How the next forty minutes are organized

How a prototype becomes production: Spec, Plan, Build, Test, Ship, Run

Great, so how do I get from here to there? Spec-driven development.

  1. Spec
    ProducesThe job, the user, and a checkable Done
  2. Plan
    ProducesA reviewable proposal: data, permissions, tests, and files
  3. Build
    ProducesThe smallest working implementation
  4. Test
    ProducesRepeatable evidence the workflow and its failure cases behave
  5. Ship
    ProducesThe approved version, live where people depend on it
  6. Run
    ProducesMonitoring, alerts, a named owner, a rollback path
evidence from use

The agent can propose, implement, and test. A person stays accountable for scope, access, promotion, and operation.

Go deeper

GitHub Spec Kit. Spec-driven development as a full toolchain. A full spec also covers source data, access rules, failure behavior, and non-goals. github/spec-kit docs

Step 1 · Spec
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

Write down the job, the user, and how you will check it

An example, worked on the starter app: the panel named Went quiet already draws this list, but never says what quiet means. The Done below is that definition, written down.

Job

Identify open deals that have gone quiet, and list them by the rep who owns them.

User

A RevOps analyst who sends the list to sales managers on Monday morning.

Done

Open deals in Prospecting, Qualification, Proposal or Negotiation whose last activity date falls before 5 May 2026, grouped by rep, with the deals carrying no activity date counted separately.

Shows the stale dealsTestableNames the stages, names the date, and says what happens to the deals with no activity date at all.

If you cannot write the steps, you do not yet know what you are asking for.

Hands on · 8 minutes
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

Write your three-line spec: Job, User, Done

When the timer ends you are holding three lines for one feature of the project you evaluated — and the Done is the line the next exercise checks.

Start from your evaluation

Copy the prompt below into your coding agent, in the folder of the project it evaluated — your own app or the starter app. Fill in the lines your evaluation returned, and pick one of the features the agent proposes.

The Done is yours

The spec comes back as Job, User, Done. Rewrite the Done as steps someone else could follow to check it.

Submit it

Share it if you want it in the mix.

The spec prompt
Read this project. Do not change anything.

Here is the evaluation this project just received:

Verdict: [paste the verdict line]
Evidence: [paste the evidence line]
First gap: [paste the first-gap line]

Propose up to three candidate features, each a bounded piece of work this project
could ship next. The first gap from the evaluation is one candidate; find the others
in the project itself. For each candidate, give me one line: what it is, who would
use it, and what would prove it done. Then stop and wait for me to choose.

When I choose, draft the spec for that one feature in exactly this form:

Job:  One sentence. The recurring task this feature performs, with its schedule if
      it has one.
User: The person or role who depends on the result.
Done: The steps another person could follow to confirm it works — written as checks
      a stranger could run, not wishes.

Underneath the three lines, four constraints:

- Source data: where the real records come from in this project.
- Access rules: who may read what, and who may change what.
- Failure behavior: what the user sees when an upstream breaks.
- Non-goals: what this version deliberately does not do.

Every line must come from what this project actually contains. Mark any line you
could not verify with the word "assumed" so I can correct it. Do not write any code
and do not propose an implementation — that is the next prompt's job.

Works in any project — the starter app or the app you brought. The agent drafts; the Done line is yours to edit. In Lovable, Base44, Replit, or v0, the same paste goes into the chat of the app you built there.

Time remaining

8:00

…

Nothing usable back before the clock? Take the pre-generated spec from the kit

Hands on · 2 minutes
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

Run the prompt and submit the rows it returns

The prompt below is built for the went-quiet list and carries the Done you wrote. When the timer ends you are holding one number — and the room's spread of that number is the lesson.

2:00
rows

A different number than your neighbor means your Done and theirs are not asking the same question. That difference is the exercise, not a mistake.

Working from the 200-row sample, or from your own app? Submit the number your Done returns there — on your own data the check is that a second run returns the same number

What you wrote

Specs you just wrote, rewritten live on this screen

Submissions appear here as their authors share them.

Nothing on screen yet. Shared specs appear here when Scott puts one up.

Step 2 · Plan
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

Approve a plan before anything changes

A plan is a proposal you can read and question: how the agent intends to satisfy the spec.

The plan prompt
Inspect the current project. Propose the smallest coherent implementation for this specification. Identify the data model, permissions, environment variables, failure states, tests, and files involved. Do not change anything until I approve the plan.

The last sentence is why the whole prompt works: it makes the plan the thing you review, and a plan is cheap to change.

Questions to ask of any plan

Does it solve the stated job?What assumptions did it invent?What data and permissions does it require?How will the core workflow be tested?What is deliberately excluded?

Go deeper

Claude Code best practices. Plan mode, context handling, and how to structure work an agent will pick up cold. code.claude.com/docs

Hands on · 3 minutes
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

Paste the plan prompt above your spec and fire it

The plan prompt
Inspect the current project. Propose the smallest coherent implementation for this specification. Identify the data model, permissions, environment variables, failure states, tests, and files involved. Do not change anything until I approve the plan.

Your own app or the starter app — the same move either way. If the agent drafted your spec, the conversation it drafted it in is the place. In Lovable, Base44, Replit, or v0, paste it into that same chat: the plan comes back before anything changes there too.

Time remaining

3:00

…

Send it, then leave it generating. Read what comes back before you approve any of it, then have the agent save the approved plan as PLAN.md in the project folder — Build starts from that file.

No plan came back? Take the pre-generated one from the kit

Step 3 · Build
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

Your agent starts every session knowing nothing about this project

Context files are the memory it lacks. Add one only when you can name what breaks without it.

Always
CLAUDE.md / AGENTS.mdCommands, conventions, what not to touch. Without it, the agent guesses.
.env.exampleCredential names, never values. Without it, invented names and secrets in chat.
Earned
SECURITY.mdWho may read and change what. Without it, routes ship with no auth check.
DATA_MODEL.mdWhat is stored and what each rule protects. Without it, silent constraint breaks.
ARCHITECTURE.mdThe decisions and why. Without it, the agent reverses one as a courtesy.
PRODUCT.mdWho it serves and what it will not do. Without it, features nobody asked for.
The context files prompt
Read this project. Write CLAUDE.md describing what is here today: how to run it, how to test it, the conventions, what not to touch. Under 60 lines.

Then list any other context file this project warrants and name what goes wrong without it. Recommend against any file you cannot justify that way. Create nothing else. Change no code.

Works on a project you have already built — the agent documents what exists rather than inventing anything. The kit carries a worked example of every file, written for the starter app.

Go deeper

AGENTS.md is the open format for this file, readable by most coding agents rather than one vendor's. The kit carries a worked example of every file above, written for the starter app. agents.md Worked examples

Step 3 · Build · connections
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

Choose how your tool connects to its data

Manual

Rare, ambiguous, or judgment-heavy work.

Costs you: stale data and human effort

Computer use

Stable interface, no usable integration.

Costs you: fragility and terms-of-service limits

API

App-to-app work at runtime.

Costs you: auth, rate limits, engineering overhead

MCP

Governed agent access to tools and context.

Costs you: connector quality and permissions

CLI

The agent driving GitHub, Vercel, Supabase, tests, logs.

Costs you: powerful access needs guardrails

Choose on

frequencyconsequencevolumeexpected lifetimestabilityretry safety

MCP is the agent's native protocol for live connections. CLI is the agent driving another platform's own tools, and your agent already speaks every CLI.

Go deeper

The MCP specification, and a list of free APIs worth building against. SEC EDGAR, Apify, and the rest — each with what it is for and what the free tier allows. modelcontextprotocol.io Free APIs for GTM tools

Step 4 · Test · test-driven development
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

A test that has never failed is not known to be testing anything

Test-driven development, run by the agent: the test is written first, fails against the current code, and the implementation exists to turn it green.

The TDD prompt
Write tests for this workflow covering: the happy path, an unauthorised access attempt, malformed input, a duplicate submission, an upstream failure, and persistence after a refresh. Confirm each test fails against the current code before you make it pass, and show me that failure.

You define the behaviour and you verify as a user. The agent writes the test, confirms it fails, implements, and runs it until green. You own the first step and the last one.

A bad response writes tests that pass immediately, or skips the unauthorised-access and duplicate-submission cases. Those two are where real tools break.

Go deeper

Give the agent a check it can run. Anthropic's current guidance on verification in agentic coding: tests, builds, screenshots, and evidence over assertion. The full prompt pack is in the kit. code.claude.com — verify its work /kit

Step 5 · Ship
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

You decide when it ships

Break things in a local copy and prove the fix on a preview link. Production is the version other people depend on.

Preview

Every change gets its own link before production. Verify the finished work as a user there.

Promote

Promotion is a decision someone makes, never a side effect of saving a file.

Roll back

The previous version stays available, so a bad promotion is undone in one step rather than debugged live.

Go deeper

Agents now run this step's guardrails: promoting a preview as an explicit step, and an agent that tests apps in a real browser. vercel.com — promote a preview replit.com — Agent 3

Step 6 · Run
  1. Spec
  2. Plan
  3. Build
  4. Test
  5. Ship
  6. Run

Watch it, log it, and name who fixes it

AnalyticsWhat it answersIs it being used, and is it creating value?Tools you can useVercel Analytics is one toggle on this stack. PostHog, Umami, and Google Analytics all have free tiers that cover an internal tool
LogsWhat it answersWhat happened on every run, for the day something looks wrong.Tools you can useYour platform's built-in logs first — Vercel's free plan forgets them after an hour. Sentry's free tier catches the errors you did not log
AlertsWhat it answersWhen it fails, a named human finds out. A log entry nobody reads is not an alert.Tools you can useSentry alert rules, or your platform's uptime checks, pointed at a channel someone actually reads

This page, in the last few minutes

  • reading…

Ownership, written down

a named owner and a backupa way to roll back a bad changeknown limitationsa review datea way to shut it down on purpose

Planning how a tool ends costs an afternoon. Skipping it is how a working tool becomes somebody's unpaid second job.

A tool nobody owns dies the first time it breaks, and the old spreadsheet comes back.

Go deeper

This project's OWNERSHIP.md, including the two items still marked undecided. OWNERSHIP.md

Hands on · 90 seconds

What a tool must have before people depend on it

1:30
  • Evidence
  • Evidence
  • Evidence
  • Evidence
  • Evidence
  • Evidence
  • Evidence
  • Evidence
  • Not yet
0 of 9

Score a tool you have built, or score the starter app you worked in this hour. Check what it passes, leave the rest blank. The blanks are your homework.

Go deeper

This site scored against all nine, with every link going to the thing itself, including the one it fails. The list is ours; each item traces to an established framework. github.com/skidubb/vibecoding-201 Where the nine come from

Keep building

Thank you.

Questions, feedback, or want to compare harness outputs? Let's keep the conversation going.