GTME University · Take-home

Deliverables

Parts 1 to 3 for the hiring committee.

Vision

Verdict

The site’s problem is routing, not organization. University already has strong content; people finish a first step and still ask “where next?”

Homepage becomes the home of a profession (not a content library). The journey becomes an orbit around a ladder measured in shipped artifacts.

How you learn is free; the checkpoints are fixed, and they test the three things no agent can do for you: specify, evaluate, diagnose.

The Builder Ladder

Shared rungs for every learner. Content layers (Foundations / Discipline / Frontier) sit alongside; you can leave for a workshop or job and re-enter at the rung you hold.

Foundations Discipline Frontier

Routed in You know your next build. Artifact: one recommended step, not a dump of every course.

First ship You ran Find → Enrich → Transform → Export once end to end. Artifact: one working FETE table (target: 40 minutes).

Repeatable play You can re-run the motion next week without rebuilding from scratch. Artifact: a reusable play or Function.

Always-on system The motion runs on signals/triggers, with a plan for when it breaks. Artifact: live loop + breakage notes.

AI control plane You operate Clay from chat/CLI with guardrails and can QA what the agent built. Artifact: MCP/CLI workflow + QA notes.

100

Credential summit You proved judgment under timed conditions: specify, evaluate, diagnose. Artifact: passed cert (Part 3).

Orbit: leave for a cohort, workshop, or job; return at the rung you hold

Clay’s guide says the unit of work is a system. The university’s corollary: the unit of progress is a shipped system. You are what you’ve shipped.

Today’s catalog, mapped to rungs

Rung 0 (Routed in): nothing today. The router does not exist; this is the biggest gap.
Rung 20 (First ship): strong. Clay 101 and the FETE framework live here.
Rung 40 (Repeatable play): partial. Claybooks and scattered courses, not organized as plays.
Rung 60 (Always-on system): thin. Cohorts touch it; no dedicated track.
Rung 80 (AI control plane): new surface. MCP/CLI setup docs exist; no course yet (Part 2 fills this).
Rung 100 (Credential summit): paused, per the homepage banner (Part 3 fills this).

The ladder doubles as the content gap analysis: build the missing rungs in order of where learners fall off.

Discipline layer · case method

The Discipline layer teaches through deep-dive live cases, case-method style: e.g. how Anthropic rebuilt its SDR motion with AI, the full thinking including the dead ends. Cases compress experience, which is where understanding actually comes from.

Every case ships buildable: a challenge pack with the scenario and constraints, an invitation to rebuild the tables yourself before seeing the reference solution, and a case-specific grade-my-table that scores your rebuild against it. Voluntary, AI-assisted or not. A watched case is content; a rebuilt case is a ship.

Who it’s for

Solver, builder, and leader are modes, not job titles. A CMO testing the ads function is a solver for an afternoon.

Solvers Need a recipe for a real job this week. Get them to first ship in 40 minutes, then invite them onto a builder track.

Builders Want the discipline. Climb rungs toward credential; courses and cohorts are fuel, not the destination.

Leaders Won’t build every table. Need literacy and a hiring bar so they can staff and evaluate GTMEs (demand side of the ladder).

Three journeys

Three stories in depth. Same ladder; different doors and first proofs.

SDR · solver story Enters via Clay 101 or Slack. First proof in 40 minutes: one outbound FETE table that lands in their sequencer. Near-term summit: a repeatable play, then Clay MCP for reps so research happens in chat.

Agency operator · builder climb Enters via cohort or a client fire-drill. First proof: a client-safe waterfall with row/credit caps. Near-term summit: always-on signals + Functions / MCP for Ops so the system is governable across clients.

CRO · leader parallel Enters via workshop or a peer. First proof is a decision, not a table: which rung is the team on, and what’s the hiring bar. The leader track is packaged school-style (the Pavilion model): short, operator-taught, one artifact per session. For leaders, the ship is a decision: a business case, a team design, a hiring bar.

Same ladder, many on-ramps: agency operator · GTM engineer · marketing professional · RevOps professional · GTM leader.

Homepage

Cold visitors get a router. The full course library stays available, but last, not first.

Router

What’s your next build?

Three quick inputs (role, goal, experience) → one recommended next step with a why

Solve Something Now

Short recipes aimed at first ship in 40 minutes for solvers who need a win today

Go Deeper

Builder tracks up the ladder; credential summit stays visible as the north star

Proof strip

Shipped artifacts, badges, and public profiles so progress is social and portable

Explore All

Today’s full library, demoted so browse is optional, not the default IA

Every content page ends with what’s next. Zero dead ends. Logged-in learners never see this page: they land on their track, place held, next build lit.

Identity

Learners are people, workspaces are employers. University accounts are personal (email or LinkedIn), GitHub-style: progress, credentials, and the profile travel with the career, not the job.

The engine

The product loop behind the IA. Grade-my-table in, share-to-profile out. Parts 2 and 3 hang off this same architecture.

01 Route

Send each person to the smallest next build for their rung

02 Ship

They submit a table; instant feedback via grade-my-table (and later critique)

03 Return

Engineered return via four triggers: recurrence, breakage, status, adjacency

04 Climb

Make the rung visible on a profile and badges so employers can read it

Activation metric: time-to-first-ship = 40 minutes (not time-to-first-video-complete)

Evidence

Why I’m confident routing is the gap, and what I’d still validate before locking the plan.

ClayMBA question log + behavioral data: learners repeatedly ask what to take next after a first win; completion doesn’t equal a clear path.
Months in the support channel: people arrive with use-cases, not course names; credit disasters show we need a “build safely” module on the early rungs.
Foundations content drifting vs product: the library ages faster than the ladder; rungs stay stable while lessons rotate.
Validate before build: entry-point analytics, 10 learner interviews across solver/builder/leader, and a Solutions/FD content pipeline so new modules map to rungs on day one.

Tactics

Concrete bets that support the ladder without becoming the strategy.

Tactic Agent-readable content (llms.txt and structured pages) so humans and their AIs can both navigate University.
Tactic Support-to-content pipeline as a Clay table: recurring tickets become rung-tagged modules.
Tactic Education partners program so external teachers map to the same checkpoints.
Tactic Enterprise cohorts with Services for teams that need a guided climb, not just self-serve.
Tactic MCP ambient learning (phase 2): teach inside the assistant after the core ladder ships.

Considered & rejected

Full AI-personalized curricula: every path unique kills shared QA, measurement, and cohort community. We personalize the router, not the rungs.

Content maximalism (ship every topic): kills the bar and ignores half-lives. Layers rotate; the ladder doesn’t.

The Clay MCP

Operate Clay from the AI assistants GTM already lives in. Full lesson videos carry the teaching; this page is the skeleton.

Course video

Intro

Who: Clay-fluent operators (SDR through RevOps) who already use Claude or ChatGPT daily, but still rebuild the same Clay work by hand in the UI.

Starting point: Can build a table and run enrichments. Has not wired Clay into an assistant as a control plane.

What you’ll build: A chat-native loop: capped table from a prompt → on-demand research → HubSpot field updates → a reusable morning-brief skill.

Aha, minute ~12: one sentence in Claude creates a capped, running Clay table. From there the course is about making that power safe and repeatable.

Problem it solves: Context switching. The thinking is in chat; the system of record is in Clay/CRM. MCP makes the assistant an operator, not a notepad.

Why GTME U (not a help article): Teaches when chat wins vs when the Clay UI still wins, plus credit risk and QA when agents build the rows. Distinct from existing “MCP for Reps / Ops” setup tours by ending in a skill + CRM compose pattern.

Course outline

Each module ends in something you can point at in Clay or Claude. Concept where it earns; hands-on everywhere else.

What are MCPs Model Context Protocol: structured actions so Claude can create tables, enrich, and read results, not just talk about them.
What are skills Reusable instruction packs (“how we brief,” “how we update HubSpot”) you load on demand so rituals don’t need a paragraph every morning.
How to connect the Clay MCP Wire Claude → Clay, authenticate the right workspace, verify with a read-only ping before any write.
Getting started with the Clay MCP Best practices, prompting (outcome + schema + stop condition), limitations, and credit-safe defaults (caps, chat/ naming).
Run your workflow from chat Build: create a capped Clay table from one prompt, kick enrichment, QA in the UI.
Research on demand Build: qualify a domain list, find decision makers, prep a call brief into structured columns, without a new Claybook ceremony.
Combining data sources Build: map Clay columns → HubSpot properties in the prompt; patch existing records only (no silent duplicates).
Your daily copilot Capstone: package a morning-brief skill that reads priority tables + stale CRM activity into ≤5 bullets.
Resources Prompt templates and skill starters learners can copy into their own Claude projects.

Vision

Verdict

The University homepage currently says certifications are paused because “GTM engineering moves fast, and Clay Certifications must evolve in unison.” That banner is the brief. This design is the version that never needs pausing again.

We certify judgment because AI commoditized execution. Anyone plus an agent can produce a working table. Clay’s own guide draws the line: commercial judgment is what separates a GTM engineer from a generic automation person. That is the line this credential certifies.

Use-case certs first; flagship stacks on top. AI in three seats, humans in one. North star: “GTME Certified” in third-party job postings. Pass rate is a feature. The bar, not the badge.

Who it’s for

Aspiring and early professional go-to-market engineers: people who want to be hired or placed as GTMEs, not SDRs collecting a badge on the side. If the career outcome isn’t “I build and own GTM systems for a company,” this isn’t the credential.

The market gap

Incumbent certs split shareability and hardness. GTME owns the white space between them.

HubSpot Easy to earn and share on LinkedIn, but hollow as a hiring signal. I hold theirs; it means nothing, even to me.

Salesforce Trusted and already in job reqs, but buried in an overwhelming catalog so the signal gets noisy.

CCIE The ordeal model. An 8-hour hands-on lab, 20 to 30% first-attempt pass rate, and the rarity is priced directly into salaries. The most respected cert in IT fails most people.

Duolingo English Test Proof an AI-native exam (AI-administered, on-demand, remote) can beat legacy credentials on access while keeping gatekeeper trust. We run that playbook in a category with no incumbent at all.

White space we take: shareable AND hard.

Pavilion certifies commitment among peers; this certifies demonstrated ability. Both valuable, different markets.

The tier stack

Like CEFR for languages: many roads in, one exam per level. Versioned and dated so the credential can evolve without another “paused” banner.

Use-case certs Scoped skills employers recognize. First: signal-based prospecting, shipable in 90 days. The Part 2 MCP course teaches the AI control plane that every exam now allows: the course teaches the how, the certs measure the what.

GTME Professional The end boss. Full judgment exam across data foundation, data modeling, data activation, and specify/evaluate/diagnose.

Architect Invite-only, later. Org-level systems design for people who set the GTM architecture, not just ship one play.

Versioned + dated · delta re-certs when the product stack moves materially

Roads are free, rungs are fixed (CEFR). Two weeks of focused work or two years on the job: same exam. Time-in-seat is not the gate.

How we assess

Generation got cheap. We stopped testing generation. We test whether you’d catch it when the machine is confidently wrong.

Agents are allowed in the build (same as the job). Silence while accepting output fails; narration of prompt → check → accept/reject is scored.

Critique is the filter: rank flawed builds, name failure modes, cost, and “what breaks when this runs always-on.”

The defense is a prior-work deep-dive on this attempt: why that waterfall, what you verified, what you’d change at 10× volume.

When agents produce the artifacts, critique becomes the exam. Checkpoints test specify, evaluate, diagnose: write the spec for a scenario, rank and critique three builds (two deliberately flawed, generated fresh per candidate), diagnose a broken or credit-burning system. Production never disappears (the BYOC build stays), but understanding is tested around it.

Critique tasks draw from the live case library (the famous cases are practice material; exams use twisted or generated variants). Graded on reasoning quality against the rubric, not answer-matching: many improvements are defensible, the justification is what separates levels.

The end-boss exam

Candidates use AI during the build because that’s the job now. Meridian-style unique case → role-play → timed build → defense.

AI-generated unique case Each candidate gets a fresh brief in the same difficulty band (e.g. “Meridian”: fictional company, real GTM constraints) so sharing answers doesn’t work.

AI role-play stakeholder Clarify ICP, budget, and success criteria with an AI “client” before you touch Clay. Grades specify skill.

Timed build (agents allowed) MCP, CLI, and UI are open. We grade constraints, credit hygiene, and decision quality, not whether you typed every cell by hand.

Async video defense (+ optional human panel) Explain tradeoffs on camera. Optional human panel for flagship / edge cases, with 48h follow-ups when convened. Default path can clear on AI pre-grade + defense rubric; humans keep veto on judgment.

AI writes the case, plays the client, and pre-grades the work. Optional human panel keeps veto on judgment. Vibe-building can produce a table. It does not survive: why did you prompt it that way, and what did you check before shipping?

Skills matrix

Pillars map to Clay’s own three rungs (data foundation, data modeling, data activation) plus judgment and communication. Extends AI-graded tables, live synthetic exercises, and Yoodli rather than replacing them.

Pillar	What it proves	Assessment
Data foundation Clay rung	Clean sources, enrichments, credit-aware design	AI-graded table + constraints
Data modeling Clay rung	ICP rules, scoring, transforms	Rubric on decision columns
Data activation Clay rung	CRM/export, triggers, always-on	Live synthetic / scheduled workflow
Specify Judgment	Brief before build; stop conditions	Written spec gate
Evaluate Judgment	Rank and critique flawed builds	Critique lab (fresh per candidate)
Diagnose + communicate Judgment	Explain the system; defend tradeoffs	Yoodli / video defense + panel

Rubric anchor · a build worth shipping

The graded build verifies exactly what Clay’s guide calls a build worth shipping: clean data in, scored or modeled, activated in a real workflow, running on a schedule or trigger. Efficiency measured in their units: meetings booked and hours saved.

Pass: dedupe before enrichment · Fail: credits burned on duplicates

Integrity

Credibility for a new credential is manufactured in public, not declared in a blog post.

Per-candidate case generation so leaked answers don’t scale.
Attempt fee + cooldown between attempts (the CCIE mechanic: funds human grading, filters for seriousness, blocks brute force).
One-click public verification of any cert (the Salesforce mechanic).
Certs issued to the person, never the workspace (GitHub identity model; no codes, no transfers, the profile travels).
Target pass-rate band stated as a design parameter, not an outcome (the CFA logic: too high diminishes prestige, too low signals unreasonableness; early years can sit low for scarcity).
Community kudos never convert into certification (praise ≠ proof).
Published rubric + published pass rate so the bar is visible.
Entry ticket to any attempt: one real build submitted through grade-my-table (qualitative, transferable, doubles as placement). No hour counts, no experience minimums: we gate with proof, not proxies.

Launch plan

Prove one use-case cert and the exam mechanics first; scale the catalog only after the badge means something.

90 days

Signal-prospecting use-case cert live (the Part 2 course teaches the control-plane skills the exam permits)
Founding class attempts a public end-boss dry run on camera
Full rubric published before the first scored attempt
Enterprise waitlist open; volume buys with Services

Year one

3 to 4 use-case certs shipped; GTME Professional flagship with optional human panel on edge cases
Placement loop + talent directory on Clay’s job board
Team-certification offer with Services for enterprise climbs
Metrics ladder ends at unprompted “GTME Certified preferred” in third-party job postings

The reputation machine

The panel is the GTM. Employers commit before launch. Authority is borrowed from individuals, then restated yearly with a dollar sign.

Employers commit before launch: hiring council drawn from Clay’s own customer logos, plus an interview pledge (any GTME Professional gets a first-round interview at council companies).

Owned turf first: seed “GTME Certified preferred” on Clay’s existing GTM Engineer job board and talent directory; third-party postings copy the pattern.

Annual State of GTM Engineering report: salaries, hiring data, and in time the certified-vs-uncertified comp delta. Respect gets restated publicly every year with a dollar sign on it.

Borrowed authority, deliberately: Anthropic-tier input on the AI-native assessment methodology (already a Clay customer), a Jacco van der Kooij-tier systems-thinking advisor on the calibration council. Individuals, never their training companies, which compete.

Considered & rejected

University partnerships: practitioner credentials earn authority from elite practitioners and hiring employers. AWS and Salesforce needed no campus; in a category we coined, borrowing academic authority concedes we aren’t it.

Mandatory case-viewing or hour requirements: watching is not understanding, and we certify what you can do, not what you sat through.

Hour / experience gates (“2 years in seat”): proxies for skill. We gate with a real build via grade-my-table, not proxies.