
Building Production GTM Tools
Evolution from Vibecoding IC work to Agentic Engineering for GTM.
Go deeper
This deck's own source code. Every claim in the next hour is checkable against it. github.com/skidubb/vibecoding-201

Which one runs Monday's retention meeting?
Vote on this screen.
This poll opens during the session.
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.
Frontier models require less step-by-step instruction. This continues to change how we prompt and how we guide agents to develop.
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

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.
Enterprise is a multiplier: procurement and security review add obligations on top of the reach floor.

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
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.
A lead-scoring model and a quota model are both code. The required checks come from consequence, not complexity.

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

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.
Choose one now. We will compare correctness, evidence, repeatability, and recovery at the end.

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 appRun 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.
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
…

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 appThe 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 CSVYour 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

Is it a prototype, a tool, or a system?
Vote what your agent came back with.
This poll opens during the session.

How a prototype becomes production: Spec, Plan, Build, Test, Ship, Run
Great, so how do I get from here to there? Spec-driven development.
- SpecProducesThe job, the user, and a checkable Done
- PlanProducesA reviewable proposal: data, permissions, tests, and files
- BuildProducesThe smallest working implementation
- TestProducesRepeatable evidence the workflow and its failure cases behave
- ShipProducesThe approved version, live where people depend on it
- RunProducesMonitoring, alerts, a named owner, a rollback path
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

- Spec
- Plan
- Build
- Test
- Ship
- 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.
| Vague | Testable |
|---|---|
| Shows the stale deals | TestableNames 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.

- Spec
- Plan
- Build
- Test
- Ship
- 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.
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

- Spec
- Plan
- Build
- Test
- Ship
- 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.
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

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.

- Spec
- Plan
- Build
- Test
- Ship
- 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.
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

- Spec
- Plan
- Build
- Test
- Ship
- Run
Paste the plan prompt above your spec and fire it
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.

- Spec
- Plan
- Build
- Test
- Ship
- 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.md | Commands, conventions, what not to touch. Without it, the agent guesses. |
| .env.example | Credential names, never values. Without it, invented names and secrets in chat. |
| Earned | |
| SECURITY.md | Who may read and change what. Without it, routes ship with no auth check. |
| DATA_MODEL.md | What is stored and what each rule protects. Without it, silent constraint breaks. |
| ARCHITECTURE.md | The decisions and why. Without it, the agent reverses one as a courtesy. |
| PRODUCT.md | Who it serves and what it will not do. Without it, features nobody asked for. |
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

- Spec
- Plan
- Build
- Test
- Ship
- 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 safetyMCP 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

- Spec
- Plan
- Build
- Test
- Ship
- 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.
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

- Spec
- Plan
- Build
- Test
- Ship
- 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
- Spec
- Plan
- Build
- Test
- Ship
- Run
Watch it, log it, and name who fixes it
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
What a tool must have before people depend on it
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
Thank you.
Questions, feedback, or want to compare harness outputs? Let's keep the conversation going.

