Go-to-market Agent Skills for developer tools and AI products, the GTM co-founder you don't have. For founders, early GTM hires, and founding AEs. Market research, positioning, ICP, homepage, launch, pricing, distribution. Grounded in Adam Frankl and Jakub Czakon.

GitHub stars
341

Install

/plugin install gtm-cofounder@gtm-cofounder

Run it inside Claude Code after adding the marketplace with /plugin marketplace add AIDevGTM/gtm-cofounder.

Contents

Discovered from source

Skills 20

Start here (your founder brief)

Every other skill is only as sharp as what the agent knows about your business. This is that context. Do it once, and every skill after it gets personal.

Use this when: it's your first time here, or the advice you're getting feels generic and textbook because the agent doesn't actually know your product, your users, or your stage.

The core idea

Answer five core questions and the agent writes a docs/gtm-cofounder/founder-brief.md in your project, enough to give you a real diagnosis and a roadmap in minutes. Everything else is optional and answered as you go: each skill pulls the deeper questions it actually needs, when it needs them, and tells you what answering unlocks. So you start seeing value fast, and the brief gets richer the more you use it, instead of facing a wall of questions on day one.

And the part that matters most: separate what you have validated (a real user who is not your friend told you) from what you are assuming (your best guess for now). Assumptions are completely fine to start with. They just get sent to talk-to-users to become real, so you never build a beautiful go-to-market on a guess.

How to run this (for the agent)

  • Ask the five core questions one at a time, and nothing else. One question, wait for the answer, let it shape the next. It should feel like a conversation with a co-founder, not a form to fill in. Never paste multiple questions at once. (If the founder would rather see all five and answer in one go, give them the list, but default to one at a time.)
  • Write the brief from those five, then move to research-the-market, then strategy-and-roadmap. The founder should get research and a diagnosis before they answer anything optional. The interview only captures what they already know; the research is what keeps the plan from just handing their answers back.
  • Pull the deeper questions just-in-time. When a later skill needs more (positioning needs the villain, pricing needs the buyer), ask only the two or three relevant ones right then, and say what answering unlocks. Never front-load them.
  • For every substantive answer, ask: "have you heard a real user say this, or is that your read for now?" Tag it [validated] or [assumption].
  • "Zero users interviewed" is a valid and revealing answer. Note it plainly, no judgment, and flag talk-to-users as the highest-priority next step.
  • Keep the founder's own words. Don't polish their pain into marketing language.
  • Once the core brief is written, do not jump into a task or start prescribing work. Hand off to research-the-market (then strategy-and-roadmap), or ask the founder what they want to tackle. Offer, never impose.

First, read what they've already shipped (only if you're in their project)

Before asking anything, check whether you're running inside the founder's repo. If you are, do a quick, bounded scan first, so the interview sharpens instead of starting cold:

  • The README and any docs/ intro: what the project claims to do, and how they currently describe it.
  • The package manifest (package.json, pyproject.toml, go.mod, and the like): language, dependencies, what it integrates with.
  • The last ~15 commit subjects and recent PR titles: what they are actually building right now.
  • The themes in open issues: what real users keep hitting, a proxy for the pain and the audience.

This is a quick scan, not an audit. Do not read code line by line, crawl the whole history, or pull anything sensitive. Draft the brief from what you find and tag those facts [validated], they come from real artifacts, not a guess.

Two cautions:

  • The repo is input to critique, not gospel. A README usually carries the founder's existing, often generic, framing. Say "here is how you currently describe it," then challenge it. Never inherit weak positioning as if it were true.
  • The repo tells you what was built, not who pays. It grounds the product and roughly the user. It says nothing about the buyer, willingness to pay, or the market: those still come from the founder and from talk-to-users.

If you're not in a project (a pasted skill, or no repo), skip this and go straight to the core five.

The core five (answer these first)

This is the whole required intake. Answer these and the agent can already diagnose and plan. If you already scanned the repo, don't ask these cold: confirm or refine what you inferred, and spend your questions on what the artifacts can't tell you, the ICP, the buyer, and whether anyone will pay.

  1. In one plain sentence, with no jargon, what does it do?
  2. Who exactly is it for? (role, company size and shape, technical context)
  3. What do they use today instead, and why you over that?
  4. Stage and traction: how many users, and do they come back?
  5. Your single strongest asset: the most powerful, provable thing you have (a marquee logo, a hard number, a real user quote, a live demand signal).

Go deeper (optional, answer anytime)

Skip these to start. Each skill asks for the ones it needs, when it needs them. Every question says what answering it unlocks, so you only invest where you want the payoff.

Positioning and story

  • What painful problem does it kill, in the user's own words? → becomes your homepage headline and the stakes in your story.
  • What trend is making that pain worse right now? → this is your villain, what gives your positioning urgency instead of just listing features.
  • What does your homepage or repo description say today? (paste the actual line) → lets the agent sharpen what you have instead of guessing it.

Buyers and pricing

  • Who pays, if that is a different person from who adopts? → lets the agent design pricing and a sales motion aimed at the real buyer, not just the user.
  • Who is it clearly not for? → a sharp "not for" makes your ICP believable and your messaging land.
  • The job they hire it for: "When [situation], I want to [motivation], so I can [outcome]." → becomes your value proposition.

Distribution and motion

  • Motion: open source, PLG, inbound, sales-led, or unsure? → picks which channels and tactics actually fit you.
  • Where do your users already hang out and discover tools? → tells us where to launch and find your first users.

Focus

  • What are you deliberately saying no to right now? (the roadmap you're protecting, the requests you turn down) → keeps the agent from recommending work you've already ruled out.

Evidence (be honest, this is the whole point)

  • Which known companies or notable developers already use it, that you can name? → your strongest proof; even a couple of logos does your credibility work.
  • How many real users have you interviewed who are not friends? → tells the agent how much of this is validated versus guessed, so nothing gets built on sand.
  • Which answers are still assumptions? → routes the guesses to talk-to-users to make them real.

Write the brief

Save the answers to docs/gtm-cofounder/founder-brief.md in the founder's project (create the docs/gtm-cofounder/ folder if it does not exist), using the template in this repo (founder-brief.template.md). Keep the [validated] / [assumption] tags on each answer. This file is the shared memory for every other skill. Write it in plain, human prose, with no em-dashes (use commas, colons, or periods), so it never reads as machine-generated.

Lead the brief with the strongest asset (core question 5) at the very top, so the single most powerful thing this founder has anchors every downstream skill. Founders routinely bury it under modesty or detail. As deeper questions get answered over time, add them to the brief under their category.

Keep it alive

The brief is a living document, not a form you fill once and forget. Every time the founder learns something real from a user (a talk-to-users call, a lost deal, a piece of feedback), update the relevant line and flip its tag from [assumption] to [validated]. A brief that is mostly [validated] is a company that knows itself. And run market-scan periodically to refresh what has changed outside the brief: a rival's rebrand, a new entrant, a shifted category.

Your next 30 minutes

  • Answer just the core five. Rough and honest beats polished and fake.
  • Tag each answer [validated] or [assumption].
  • Save it as docs/gtm-cofounder/founder-brief.md in your project so your agent reads it.
  • Run research-the-market so the agent finds what you didn't tell it: where your users actually are and how products like yours launched.
  • Run 01-strategy-and-roadmap to get your diagnosis and first move. Don't answer the optional questions yet.
  • Answer deeper questions later, only when a skill asks and tells you what it unlocks.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If the brief surfaces something you'd rather pressure-test with a human before you build on it, that's what I'm here for. Reach out to me on LinkedIn.

Strategy and roadmap (your plan)

A pile of tactics is not a go-to-market. This turns your brief and the market research into a diagnosis and a prioritized plan, and becomes the one place you come back to when you don't know what to do next.

Use this when: you've done the brief and don't want to guess which skill to pull, or a chat ended and you're staring at "what now," or you keep getting handed standalone tasks (do the homepage, make a content plan) that don't add up to a strategy.

The core idea

The other skills are moves. This is the game plan that decides which move, and when. It does three things:

  1. Diagnose. Read the brief and the research honestly. Where are you actually strong? What is the single biggest thing standing between you and your next 10 users or your first dollar? Name one bottleneck, not five.
  2. Prioritize by stage. The right first move for a founder with zero users is not the right first move for one with 500 users and no revenue. Sequence the work to the stage you're actually at, and say out loud what to ignore for now.
  3. Persist. Write it to docs/gtm-cofounder/gtm-roadmap.md so it survives the chat. Next session you read the roadmap, not a dead thread.

How to run this (for the agent)

  • Read docs/gtm-cofounder/founder-brief.md and docs/gtm-cofounder/market-research.md first. If the brief does not exist, run start-here before this. If the research does not exist, run research-the-market before this, or, if the founder wants to skip it, say plainly that the plan will only reflect what they told you and mark it brief-only.
  • The plan must add something they didn't bring. A roadmap that only rearranges the founder's own answers has failed, however well organized. At least one move in Now or Next has to come from the research (a venue, a launch pattern, a segment, an opening), and the roadmap names what the research changed.
  • Name places, not categories. Any channel, launch, or outreach move names the specific venue from the research: "post in the subreddit the research ranked first, inside its weekly self-promo thread, then pitch the two newsletters it found", with the names and links, not "post on Reddit and reach out to newsletters".
  • Lead with a diagnosis, not a task list. Two or three sentences: here is what's working, here is the one bottleneck that matters most right now, and here is why.
  • Be willing to tell them to do almost nothing. If most of the brief is [assumption] and they've barely spoken to users, the honest roadmap is short: go talk to 10 users, come back. Do not pad it to look thorough.
  • Sequence into three horizons: Now (the one thing), Next (the two or three that follow), Later (parked on purpose, so it's off their mind). Map each item to a skill.
  • Offer, never impose. Present the roadmap and ask what they want to start with. Do not assign or begin a task they have not chosen. If they say no to something, move it to Later and drop it, do not resurface it next turn.
  • Write the plan, not a copy of the brief. docs/gtm-cofounder/gtm-roadmap.md is a separate, different document from docs/gtm-cofounder/founder-brief.md. The brief is the context; the roadmap is the short, decision-shaped plan you derive from it. Never re-save the brief's contents into the roadmap. If docs/gtm-cofounder/gtm-roadmap.md does not open with a one-line Diagnosis, then What the research added, then Now / Next / Later, it is wrong.

Stage decides the first move

Use the brief's stage and evidence answers to pick the starting point, and the research to make the move specific. A rough guide, not a law:

Where they areThe bottleneck is usuallyStart with
Pre-users, mostly [assumption]You don't yet know who it's for or whether the pain is realtalk-to-users, then who-is-this-for
A few users, can't describe themFuzzy ICP, so nothing else can be sharpwho-is-this-for, then positioning-and-story
Users but the message is genericPositioning and homepage speak to no onepositioning-and-story, value-prop-that-converts, the-homepage
Good product, nobody arrivesDistribution: no first channel that worksfirst-50-users, then launch-it
First 50 in hand, growth stalls when you stop pushingEvery user is hand-made; usage creates no new usersgrowth-loops
Developers love it, nobody paysThe buyer vs user gapmarket-to-devs-sell-to-buyers
Growing but flying blindNo read on what's actually workingknow-if-its-working

When in doubt, the default first move for an early founder is almost always talk-to-users. Real evidence beats a clever plan.

The roadmap file

Save to docs/gtm-cofounder/gtm-roadmap.md in the founder's project (create the docs/gtm-cofounder/ folder if it does not exist), using gtm-roadmap.template.md in this repo. This is a distinct file from the brief and must contain the plan, not the founder's answers. Keep it short and living:

  • Diagnosis: the one bottleneck, in a sentence.
  • What the research added: the two or three things from market-research.md that shaped this plan and that the founder didn't tell you, each with its link.
  • Now: the single next move, the skill it maps to, and what "done" looks like.
  • Next: two or three moves queued behind it.
  • Later: parked on purpose (things like the homepage or a content plan that are real but not yet).
  • Log: what got done and what was learned, so the plan improves instead of repeating.

Coming back to it (every session)

This is the fix for "the chat ended and I don't know what to do next." Start each session here:

  1. Read docs/gtm-cofounder/founder-brief.md, docs/gtm-cofounder/market-research.md, and docs/gtm-cofounder/gtm-roadmap.md.
  2. Say where things stand and the one next move, in a sentence or two.
  3. Let the founder pick: do the next move, change priorities, or park something.
  4. After the work, update docs/gtm-cofounder/gtm-roadmap.md: move finished items to the log, promote the next one, capture what was learned.

You are not a menu of skills they have to operate. You're the co-founder holding the plan.

Your next 30 minutes

  • Make sure docs/gtm-cofounder/founder-brief.md exists. If not, run start-here.
  • Make sure docs/gtm-cofounder/market-research.md exists. If not, run research-the-market.
  • Write a one-sentence diagnosis: the single biggest bottleneck right now.
  • Fill docs/gtm-cofounder/gtm-roadmap.md: one Now, a short Next, an honest Later.
  • Pick the Now move and open its skill. Just that one.
  • Next session, come back here first. Don't start from a blank chat.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If your roadmap has a fork this can't call, or you want a second set of eyes before you commit a quarter to it, reach out to me on LinkedIn.

Who is this for?

"Developers" is not a market. It's a medium. If your ICP doesn't exclude anyone, it isn't one.

Use this when: you describe your user as "developers" or "engineering teams," you can't name a person who is clearly not a fit, or you're aiming your messaging at the VP of Engineering because they have the budget.

The core idea

A usable ICP is specific enough that some people are obviously out. "Every developer" gives you nothing to say, because a message that speaks to everyone speaks to no one. Sharpen until exclusion is possible.

And in almost every AI/dev-tool sale there is more than one person: the developer who adopts is rarely the person who pays. Market to the adopter; sell to the buyer. Confuse the two and you get great meetings and no decisions.

Framework 1: The personas in the sale (Frankl)

Map who plays each role. You need all of them for a complex sale; skip one and the deal stalls.

PersonaCares aboutRole in the sale
Alpha Dev"What's possible?" Lives in the future. No budget.Finds you, experiments, advocates internally, creates social proof
Empowered CTOKairos, weeks off a release cycle, competitive edge. Has budget.Approves spend and strategic fit
VP EngineeringTeam velocity, DX, quality at scale. Fears downtime/securityEvaluates feasibility, tests in staging
SRE / Platform EngReliability, less toil. Reads your code before your copy.Gatekeeps operational risk

The Alpha Dev is not your long-term customer. They chase the next shiny thing. You need them anyway: they carry new tech to the people who pay.

Framework 2: Jobs to be done, not demographics (Czakon)

A job title is not actionable; a job is. Write it as:

When [situation], I want to [motivation], so I can [expected outcome].

Example: "When I inherit a service with no tests, I want to generate a safety net fast, so I can refactor without fear." That sentence tells you the trigger, the pain, and the win. A demographic never does.

Decision tree: single-player or complex sale?

Does the developer who adopts also control the budget?
├─ YES  → single-player / PLG motion.
│         ICP centers on the adopter. Optimize time-to-value, self-serve, transparent pricing.
└─ NO   → complex sale.
          ICP centers on the adopter FOR ADOPTION, and the buyer FOR REVENUE.
          You need a "what's in it for me" for every persona above.

Sharpen it: the 5-attribute ICP

Fill every line with something a stranger couldn't guess:

  1. Company shape: stage, size, team structure (e.g. "50-500-engineer companies with a platform team")
  2. Technical context: stack / recent change (e.g. "just adopted Kubernetes")
  3. The trigger: what just happened that makes this urgent now
  4. The pain, in their words: the exact phrase they'd use (get this from talk-to-users)
  5. Who says no: the segment you are deliberately not for

Mistakes that look reasonable

  • TAM theater: "there are 30M developers." True and useless. Nobody sells to 30M anyone.
  • Budget-chasing: writing everything for the CTO/VP because they pay. They don't visit your homepage; the developer does.
  • Persona = job title: "backend engineers." That's a hat, not a human. Use the job.
  • One persona, complex sale: nailing the Alpha Dev and forgetting the buyer → adoption with no revenue.

Example

❌ "For developers who want to ship faster." ✅ "For platform engineers at 50-500-eng companies who just standardized on Kubernetes and are drowning in hand-written YAML, the ones who'd say 'I spend a day a week on manifests I shouldn't have to touch.' Not for solo devs on Heroku."

Your next 30 minutes

  • Write your ICP with all 5 attributes filled in, including who says no.
  • List every persona in your sale and mark: who finds it, who evaluates it, who pays.
  • Rewrite your one-line pitch as a Job To Be Done (When… I want… so I can…).
  • If you couldn't fill attribute #4 in their real words → you owe yourself talk-to-users before anything else.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). Stuck on whether the ICP is right, or seeing two personas pull in different directions? That's worth a human call. Reach out to me on LinkedIn.

Talk to users (the TAB system)

The best marketing to developers comes from talking to developers. That's it. Everything else in this repo is downstream of this skill.

Use this when: you've never done a real user interview, your messaging is clever but unverified, or you keep debating the roadmap internally instead of asking the people who feel the pain.

The core idea

Stand up a Technical Advisory Board: 30-50 people who represent your users and buyers, not grey-haired advisors telling you how to build. You interview them, on repeat, and let their words become your positioning, roadmap, and homepage copy.

A TAB call is not a demo and not a sales call. It's an interview. You never mention the product.

Framework: the TAB system (Frankl)

Composition

  • One+ representative of every persona that touches the product (see who-is-this-for)
  • Both users (interact) and customers (pay), often different people
  • Target 30-50 members

Cadence

  • 30 minutes · one-on-one · monthly · for ~6 months
  • Zoom, recorded with permission, never in person
  • Same questions every time · never pitch

Recruitment (it's a numbers game)

  • Personalize every message, never batch-and-blast
  • Lead with their problem, not your startup
  • Start from "the problem in their words" in docs/gtm-cofounder/market-research.md: those are real people who already posted about the pain, with links
  • Max 4 sentences
  • ~10% reply → plan ~500 outreaches for ~50 members
  • No payment: early access, influence, swag

Template:

Dear [Name],

Your post about [specific problem] was genuinely sharp.

I'm building something to attack [that problem] and I'd value your view. Would
you consider joining my technical advisory board?

If so, reply and I'll set up a short call to explain what's involved.

The 7 questions (never more than 7 in 30 min)

  1. Magic wand: "If you could wave a magic wand and change anything about how you do [task], what would it be?"
  2. The stakes: "If we delivered that, how would it change your day / your work?"
  3. Why now: "What's different about the world now that makes this more valuable than five years ago?"
  4. What caused this problem in your org?
  5. What have you tried, and why did it fall short?
  6. What happens if nothing changes for another year?
  7. Where do you go to stay current on this? (who/what they trust)

Analyze: turn transcripts into assets

Highlight complete sentences (not fragments) into four buckets, then synthesize the top 3-5 of each, in the interviewee's exact words:

BucketYou're mining for
Painsbad outcomes, risks, obstacles
Gainsoutcomes they want
Jobswhat they're trying to accomplish
Environmental changestrends making the pain worse over time → your villain

Those four buckets feed directly into positioning-and-story and value-prop-that-converts.

Mistakes that look reasonable

  • Interviewing friends: they're nice and useless. You need people who'll say no.
  • Pitching mid-interview: the moment you demo, they start being polite instead of honest.
  • Leading questions: "wouldn't it be great if…" gets you the answer you fished for.
  • Batch outreach: a templated blast to 200 people gets 200 ignores. Personalize or don't send.
  • Asking for solutions: users are experts in their pain, not in your product. Mine the pain.

Your next 30 minutes

  • List every persona from who-is-this-for; you need TAB members for each.
  • Find 10 people who've publicly posted about the problem (HN, Reddit, GitHub issues, X). If you ran research-the-market, your first list is already in market-research.md.
  • Send 10 personalized, 4-sentence, problem-first invites. Today.
  • Lock your 7 questions (3 above + 4 tailored). Do not exceed 7.
  • After 3 calls, fill the Pains/Gains/Jobs/Changes table with real quotes.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If you want help standing up a real Technical Advisory Board, or reading what your interviews are actually telling you, reach out to me on LinkedIn.

Positioning & story

Your story is boring without a villain. And you are not the hero of it. The developer is. You're the wise advisor who hands them a better weapon.

Use this when: your homepage explains what your product does before it names the problem, your positioning is interchangeable with three competitors, or nobody feels any urgency to act now.

The core idea

Developers don't buy features; they hire a tool to defeat something that's making their life worse. Get the roles right:

  • Hero = the developer (never the vendor, never the product)
  • Villain = the undeniable trend making the pain worse every day
  • Wise Advisor = you, arriving with a gift (the product)
  • Inciting event = the change in the world that forces the hero to act now

No villain → no urgency → no story → no conversion.

Framework: the 3-part story (Frankl)

  1. Inciting event: introduce the hero and the villain; the world changed and the hero can't stay put.
  2. Obstacles: a series of specific challenges, each solved with your help, best told as mini before/afters: "Before X, we had [problem]. Now [measured result]."
  3. Resolution: villain defeated (for now), specific results, hero shares the wisdom → that's your testimonial.

The benchmark (EngFlow):

"Slow builds waste your time. Standard build tools can't handle today's codebases. Speed up builds now to keep engineers in flow."

  • Pain: slow builds waste your time
  • Villain: standard tools can't handle modern complexity
  • Hero: engineers, kept in flow
  • Wise Advisor: the build experts

Good villains: cloud-cost sprawl · tool fragmentation · compounding tech debt · flaky pipelines · observability gaps · manual deploys · YAML sprawl · agents you can't trust in prod.

Framework: the 4 levels of differentiation (Frankl)

Compete as high up this ladder as you can. Feature wars are a race to the bottom.

LevelTypeSounds likeGrade
1Feature"we have X, they don't"D
2Benefit"we save you time"C
3Customer segment"for CTOs under release pressure with compliance"B
4Problem"the only fix for [problem no one else has named]"A

Reaching Level 4 / category creation: talk to enough TAB members (see talk-to-users) to surface a problem competitors haven't named, then name it so precisely your product is the obvious answer. When rivals adopt your vocabulary, they've already lost the position. (JFrog: "artifact repository" → "Universal Artifact Repository" and leapfrogged Sonatype.)

Decision tree

Can you state a problem only you solve, in the user's words?
├─ YES → Level 4. Lead with the problem; name the category.
└─ NO  → Can you name a specific segment with a compelling reason?
         ├─ YES → Level 3. Lead with the ICP + their trigger.
         └─ NO  → you're stuck at feature/benefit → go run `talk-to-users`.

Mistakes that look reasonable

  • Product as hero: "ShipFast helps you…" Make the developer the subject of the sentence.
  • No villain: all solution, no antagonist → zero urgency.
  • "Platform": developers hear months of integration and risk. Name the specific thing it does.
  • "Pleased to announce": nobody cares about your emotional state; a feature is not a story, a customer win is.
  • Feature-matrix positioning: a checklist vs competitors keeps you at Level 1 forever.

Your next 30 minutes

  • Write one sentence: hero + villain + inciting event (steal the EngFlow shape).
  • Grade your current differentiation 1-4. If it's D/C, list what would move it to B/A.
  • Find the villain in your talk-to-users "environmental changes" bucket, it's already there.
  • Rewrite your headline so the developer is the subject and the problem comes before the product.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). Positioning is the one most worth a second opinion before you ship it everywhere. If you want yours pressure-tested, reach out to me on LinkedIn.

Beyond the wrapper (positioning an AI product)

"AI-powered" is the new "powerful." When the model is a commodity anyone can call, your positioning cannot be the model. It has to be the problem you solve, the trust you earn, and the last mile nobody else does.

Use this when: people call your product "just a GPT wrapper," you blend into fifty tools that demo the same thing, buyers worry about accuracy or where their data goes, or you cannot answer "why won't OpenAI or Anthropic just build this?"

Not building an AI product? Skip this one. It is the one skill here that is not for everyone, and nothing else in the pack depends on it. Move straight on to value-prop-that-converts. Come back only if the "is this just a wrapper?" question ever lands on you.

The core idea

Half your competitors have the same model behind them, so the model cannot be your pitch. The "wrapper" objection is not a technology problem, it is a positioning problem: you are being described at the feature level (see positioning-and-story), and features that call the same API are interchangeable. The work is to move up a level, to the specific problem, the specific buyer, and the specific reasons a developer would trust you over a weekend prototype and their own API key.

And a hard truth from developer psychology: developers will test your claims and find the truth. If you overclaim what the AI does, they will find the case where it fails, and you lose them for good. So in AI, honesty about limits is not a weakness. It is the differentiation.

Where the moat actually is (name yours)

The model is rented, and everyone rents the same one. Your defensibility is one of these, so say which:

  • Proprietary data or context the raw model does not have (your users' data, your domain corpus, live signals).
  • Workflow depth a model plus a prompt cannot touch (the last mile: integrations, UX, the ten unglamorous steps around the generation).
  • Domain expertise encoded as evals, guardrails, and judgment a general model gets wrong.
  • Reliability and trust: it works in production, not just in a demo.
  • Distribution: you are already in their stack.

Positioning line to work toward: "The model is a commodity. The [your real moat] is not."

Trust is the product

For an AI tool, reliability is the whole game, and every buyer has been burned by a confident wrong answer. So position on it, out loud:

  • Do not overclaim accuracy. Publish what it is good at and where it fails. Devs trust the tool that tells them its limits.
  • Show your work: evals, benchmarks on real tasks, what happens when the model is unsure, where a human stays in the loop.
  • Close the demo-to-production gap. Anyone can demo an AI thing. The wedge is being the one that survives edge cases, weird inputs, and real data. Position on production, not magic.
  • Answer the data question before they ask: where does their data go, is it used for training, can they self-host or keep it in region. For many buyers this decides the deal, not output quality.

The two objections you will always get

"Isn't this just a wrapper?" Do not get defensive. Agree the model is commodity, then name the part that is not: "The generation is the easy 20 percent. We do the [data / workflow / reliability / domain] that makes it usable in production." If you cannot name that part, that is the real problem, and it is a product problem, not a pitch problem.

"Won't OpenAI or Anthropic just build this?" Answer in one sentence or you do not have a wedge yet. The honest answers are usually: they build horizontal capability, you win on a vertical, workflow, or data set they will never go deep on. Or: you ride their improvements (every model release makes you better) instead of competing with them. Pick the true one and say it plainly.

Stop leading with "AI"

"AI-powered" is puffery now, the same class of word as "powerful," "seamless," and "platform" (see value-prop-that-converts). Developers skim past it. Lead with the job done; the AI is the how, not the headline. "Turn X into Y in seconds" beats "AI-powered X platform" every time. Test it: if your pitch still makes sense with the word "AI" deleted, you are positioned on the problem. If it collapses, you are positioned on the technology.

Mistakes that look reasonable

  • Leading with the model or "AI-powered." It signals commodity and invites the wrapper objection you are trying to avoid.
  • Overclaiming accuracy or hiding failure modes. Devs find the failure case, and the trust never comes back.
  • Competing on model quality. You do not control the model. Compete on the last mile.
  • Ignoring the data question. For enterprise and EU buyers, "where does our data go" often outranks output quality. Silence reads as a red flag.
  • A great demo and no production story. The demo gets the meeting. Reliability gets the renewal. Demo only, and you have a toy.
  • No answer to "won't the big labs build this." If you cannot say it in a sentence, you have not found your wedge.

Your next 30 minutes

  • Write your pitch, then delete the word "AI." If it still says what you do and for whom, good. If it collapses, rewrite it around the problem.
  • Name your real moat in one line: "The model is a commodity. Our [data / workflow / reliability / domain] is not."
  • Write the one-sentence answer to "won't OpenAI or Anthropic just build this?" If you cannot, that is your most important strategic question this month.
  • List your top three failure modes and decide how you will show, not hide, them (evals, "here is where it struggles," human-in-the-loop).
  • Answer the data question on your site before a buyer has to ask: where it goes, training, self-host or region.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If "just a wrapper" is a fight you're losing and you want help finding the real wedge, reach out to me on LinkedIn.

The value prop that converts

"Better" is sloppy thinking. Better how, along what dimension, by how much, proven by whom? Developers test every claim you make. Give them numbers or give them nothing.

Use this when: your value prop contains puffery, your claims aren't attributed, or you're trying to make one sentence do the job of two audiences.

The core idea

Developers have a finely tuned BS detector and they will verify you. Specificity is credibility. Every strong dev value prop is: specific + provable + spoken in their language.

Framework: the value-prop rules (Frankl)

  1. Never say "better." Say better how, by how much, versus what.
  2. Time savings must be specific. ❌ "saves developer time" · ✅ "8× faster builds, 2 hrs → 15 min" (attributed).
  3. Two kinds of time, speak to both:
    • Chronos (Alpha Dev): clock hours saved per week.
    • Kairos (Empowered CTO): calendar time, weeks off a release cycle, competitive edge.
    • The same product must land both. "Release fast or die" worked for developer and CTO.
  4. Every claim needs proof. A demo is the weakest proof (ideal conditions). An attributed testimonial (name + title + company + number) is the strongest. Anonymous quotes are assumed invented.
  5. Sell the category, not the solution. Talk about the problem and the need for "a tool like this"; don't proactively pitch features; it trips developer defenses.
  6. Never "pleased to announce" / "excited to share." No one cares how you feel.

Framework: the three dimensions of a dev value prop (Czakon)

A complete value prop answers all three, fast:

  • What is it?: category / known-incumbent comparison / plain statement ("a Datadog alternative," "CI for monorepos").
  • For whom / what use case?: the ICP and the job (from who-is-this-for).
  • Why you over the 10 alternatives?: the legitimate, provable reason to exist.

Headline = what is it. Subhead = for whom / what job. For dev tools, weight the how over the why. Developers often already know why they hurt.

The puffery detector: flag and replace

BannedWhy devs discount itReplace with
Powerfuleveryone claims itthe specific thing it does
Easy to usethey'll test it in 60stime-to-value with a number
Best-in-classsays who, by what metricthe source or the number
Seamless integrationunprovable in the abstractnamed integrations + logos
Industry-leadingsays nothingreal share / user counts
Platformhears: integration headachethe one job it does
Revolutionary / cutting-edgepure airname the actual technology

Proof hierarchy (weakest → strongest)

your claim  <  a demo  <  a benchmark you ran  <  a named user's attributed result

Spend your effort at the right end.

Mistakes that look reasonable

  • Adjective stacking: "powerful, seamless, intuitive." Three words, zero information.
  • One line, two audiences: a Chronos-only message loses the buyer; a Kairos-only message loses the adopter.
  • Unattributed social proof: "developers love us." Which developers? At which company?
  • Leading with the why: for most dev tools the pain is known; lead with the how and the proof.

Your next 30 minutes

  • Run your homepage copy through the puffery table. Delete or replace every hit.
  • Rewrite your #1 claim with a number and an attribution (even a single named user).
  • Write one Chronos line (hours/week) and one Kairos line (weeks/release). Make sure both exist.
  • State your value prop as the three dimensions: what · for whom · why you.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If you can't tell whether your value prop actually lands with a buyer, get a human read. Reach out to me on LinkedIn.

The homepage

Write your homepage for the person who actually reads it: the end-user developer, not the CTO who signs the check. The developer becomes your champion and sells it internally for you.

Use this when: your homepage speaks to buyers/ROI, it's clever but vague about what the thing does, or a developer can't tell in 5 seconds whether to care, and can't start in 5 minutes if they do.

The core rule (Czakon)

Address end-user developers on the homepage; put enterprise/ROI/buyer messaging on separate pages (enterprise, pricing, case studies). If you write the homepage for the buyer, you've written it for someone who isn't there.

Framework: the sections, in order (Czakon)

  1. Hook / core message: immediately: what is it? Use a category ("CI for monorepos"), a known-incumbent comparison ("a Datadog alternative"), or a plain statement. Headline = what it is · subhead = for whom / what job.
  2. Hero: a real product shot; two CTAs: Get started (signup) and Docs. Answer "what's in it for me?" up top. Lead with the how, not the why.
  3. Social proof, right after the hero: recognizable logos are the fastest credibility you have. Impressive dynamic metrics (users, stars) if you've got them.
  4. Value prop & differentiation: why you over the 10 alternatives (see value-prop-that-converts).
  5. Getting started: a huge conversion lever. Free trial, no credit card, quick setup. Any hard barrier sends developers straight to a competitor.

Design: clean typography, breathing room, no "salesy BS," minimal heavy interactions. An embedded playground / copy-pasteable snippet creates an instant aha.

Framework: what must be on it (Frankl)

Cross-check the copy has all six:

  1. the problem in the customer's language (before the solution)
  2. the villain / undeniable trend
  3. attributed proof with numbers (name · title · company)
  4. the inciting event / urgency
  5. social proof (not anonymous)
  6. a low-friction path to try (free tier · docs · GitHub)

The MVP website (Czakon)

Don't build everything. Start with: homepage · docs · pricing · navbar (login, signup, contact, GitHub) · About (an About page builds trust for an unknown brand). Add later, deliberately: case studies → comparison pages → blog → templates → sandbox → enterprise page.

Transparent pricing. "Contact sales for pricing" reads as "expensive and slow." Show a number wherever you can.

Decision tree: hero CTA

Can a developer get value self-serve?
├─ YES → primary CTA "Get started" (signup/download) + secondary "Docs".
└─ NO  → primary CTA "Read the docs" / "See how it works"; don't fake a signup that dead-ends.

Mistakes that look reasonable

  • Writing for the buyer: ROI language up top; the developer bounces.
  • Why before what: three sentences of vision before you say what it is.
  • "Contact sales" pricing: kills self-serve trust instantly.
  • No getting-started: a beautiful hero and no obvious first step.
  • Puffery hero: "The powerful, seamless platform for modern teams." Says nothing (run value-prop-that-converts).

Your next 30 minutes

  • Read your hero as a skeptical developer: in 5 seconds, do you know what it is and if it's for you?
  • Confirm the five sections exist in order; move buyer/ROI copy to its own page.
  • Put a no-credit-card getting-started step above the fold or one click away.
  • Run the page through ShipReady for the full 10-point scorecard.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). Want a line-by-line teardown of your actual homepage from someone who's done hundreds? Reach out to me on LinkedIn.

Time to first value (get them to the first win)

For a dev tool, the product is the pitch. A developer tries it alone and decides in minutes. Acquisition without activation is just a faster way to lose people.

Use this when: people sign up or star the repo and then nothing, they get it working once and never come back, your docs assume the reader already understands it, or you are about to spend on a launch or a channel while the first ten minutes still leak.

The core idea

You can nail your positioning, your homepage, and your launch, and still lose everyone in the first ten minutes. For a dev tool the first run is the sale: the developer tries it, alone, without talking to you, and decides. Two gates, straight from Frankl's DREAM funnel:

  • Evaluation: can they get it working over a weekend, with zero human help? (the weekend test)
  • Activation: how fast do they reach their first real win, the "I'm awesome" moment (time to first value)?

Fix this before you scale acquisition. Pouring users into a leaky first run just loses them faster, and know-if-its-working will show you that retention, not signups, is the number that matters.

The two thresholds

The weekend test (Frankl). A motivated developer should get your product doing something real over a weekend, without a call, a demo, or an email to you. If they cannot, that is your single highest-leverage work, above any channel, launch, or homepage tweak.

Time to first value (Czakon: "time to Hello World"). Measured in minutes, not hours, and the first meaningful win in the same sitting, not after an onboarding call next Tuesday. The first "Hello World" should be minutes in; the first real "oh, this is useful" should be that same session.

The win belongs to the developer, not your product (Frankl: the developer is the hero). The aha is "look what I just did," not "look what our platform can do." Design the first run so the developer feels capable, fast.

Framework: the friction log (Czakon)

The core tool. Do not try to document every path. Nail the ONE most common path to first value.

  1. Pick the single core journey a new developer takes to their first win.
  2. Walk it yourself as a stranger: new machine or incognito, no insider shortcuts, no filling in gaps from memory.
  3. At every step, log three things: the question they have, the frustration they hit, the friction or barrier that makes them stop.
  4. Fix the obvious barriers first. Cut the top three places a motivated dev would quit.
  5. Put a metric on each core moment so you can see where they drop.

What removes friction (and what adds it)

Removes it:

  • Free tier or trial, no credit card, no "contact sales" (Czakon: hard barriers send devs straight to a competitor).
  • An idiot-proof install and a copy-pasteable example that works on the first try.
  • A "get started in 5 minutes" path, and a docs quickstart written for the stranger, not the expert.
  • A sandbox or demo populated with data close to their real use case, not foo and bar (Czakon: realistic sandbox data gets you most of the way).

Adds it:

  • A signup wall, a sales call, or a credit card in front of the first win.
  • Docs written by someone who already understands the product.
  • A first run that shows off your architecture instead of getting the developer to their result.

Decision tree

Can a motivated new dev reach a real win alone, in one sitting, without talking to you?
├─ NO  → this is your highest-leverage work, above any channel or launch.
│         Run a friction log on the one core path and cut the top 3 barriers.
└─ YES → do they come back the next week?
         ├─ NO  → the first win isn't valuable or sticky enough. Wrong "aha,"
         │         or no reason to return. Re-pick the activation moment.
         └─ YES → now acquisition is worth scaling. Go to `first-50-users`.

Mistakes that look reasonable

  • Optimizing the homepage or the launch while the first run leaks. Fix activation before acquisition. A great channel into a broken first run just burns the channel.
  • Celebrating signups. Signups are vanity if they never activate. Watch time to first value and week-one activation, not the top of the funnel (see know-if-its-working).
  • Gating the first win behind a wall, a demo, or a credit card. Developers bounce and do not come back.
  • Making your product the hero of the first run. The developer is the hero. The moment is "look what I did," not "look what it does."
  • Writing docs for the expert. The quickstart is for the stranger who has never seen it. Test it on one.
  • Documenting every path. Nail the one common path first. Perfect coverage of a journey nobody takes is wasted work.

Your next 30 minutes

  • Name the ONE core path a new developer takes to their first real win. Just one.
  • Walk it as a stranger (incognito or a clean machine), and time it. Log every question, frustration, and barrier at each step.
  • Circle the first three points where a motivated dev would give up. That is your backlog, ahead of any marketing task.
  • Define the single "I'm awesome" moment, and make it reachable in minutes, in one sitting, with no human help.
  • Put one number on it: time to first value, or the percent of signups that reach the win in week one. Watch it like you watch uptime.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If activation is leaking and you can't see where, that's worth a human pass over the funnel. Reach out to me on LinkedIn.

Your first 50 users

You don't get your first 50 users by posting more. You get them by going where your users already discover tools, and, at the start, by doing things that don't scale.

Use this when: you launched to silence, you're spraying every channel hoping one works, or you're about to buy ads to fix a problem ads can't fix.

The core idea

Every developer audience has an existing technology-discovery loop: the specific places they already go to find new tools. Your job isn't to invent demand; it's to position yourself inside that loop. And your first cohort is hand-to-hand: the TAB members from talk-to-users are your first users.

Framework: the top of the DREAM funnel (Frankl)

  • Discovery: be where developers look: the communities, newsletters, influencers, and searches your ICP already uses. Metric: unique humans, not pageviews.
  • Research: give the interested dev a next step before they forget you: newsletter, Discord, free tier, docs. Developers can sit in Research for months, so sustain the relationship.

Then Evaluation decides everything (see know-if-its-working): can a new dev get value over a weekend, from docs and Stack Overflow, with no support call? If not, more traffic just fills a leaky bucket.

Framework: channels by stage (Czakon)

Pre-PMF (you are here for the first 50): unscalable, direct, high-touch.

  • The people who posted about the problem (HN/Reddit/GitHub issues/X), DM them, personally.
  • Your TAB → convert to design partners / first users.
  • Founder posting genuinely useful things where the ICP hangs out (not "we launched!").
  • One deep launch (see launch-it), not ten shallow ones.

Post-PMF (later): content/SEO, community, dev-influencer partnerships, then paid to amplify what already converts, never to discover it. And once the first 50 are in and retention holds, the hand-to-hand work graduates: build the self-reinforcing engine in growth-loops.

How to pick the channel (don't do all of them)

You should already have two sources: the ranked watering holes in docs/gtm-cofounder/market-research.md (from research-the-market), and what real users told you in talk-to-users question 7 ("where do you go to stay current?"). Where they agree, that's your channel. Where they disagree, trust the users. If there's no research file yet, or it's more than a quarter old, run research-the-market first: picking channels from memory is how you end up "posting more" in rooms your ICP isn't in.

Rank channels by where your specific ICP is, and go deep on one before adding a second. Always by name: a specific subreddit, Discord, newsletter, or GitHub issue thread, never "Reddit" or "communities".

Is your ICP concentrated somewhere specific (a subreddit, a Discord, a conference, a tag)?
├─ YES → go all-in there first. Depth beats spread at 0→50.
└─ NO  → your ICP may be too broad → tighten it in `who-is-this-for`.

Mistakes that look reasonable

  • "Post more": volume without a channel thesis is noise.
  • Paid ads pre-PMF: you'll pay to accelerate a message that doesn't convert yet.
  • Building a community at 5 users: a Discord with 3 lurkers is a graveyard that signals "dead." Wait for real traction.
  • Optimizing acquisition over a leaky bucket: if week-2 retention is near zero, fix Evaluation/Activation first.
  • Launching ten times, shallow: one well-prepared launch > ten "we shipped X" tweets.

Your next 30 minutes

  • Write down the 3 exact places your ICP discovers tools, by name and link (from market-research.md, checked against talk-to-users Q7).
  • List 20 people who publicly posted about your problem (start from "the problem in their words" in market-research.md). DM 5 today, helpful, not pitchy.
  • Turn your best 5 TAB members into your first 5 users this week.
  • Confirm a new user can hit first value in under an hour. If not, that's the real priority.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If the first users aren't coming and you're out of channels to try, reach out to me on LinkedIn.

Launch it

Developer communities reward the honest, technical, slightly humble builder and punish the marketer instantly. A Show HN is not an announcement. It's "I built this thing, here's how it works and what's still rough."

Use this when: you're scared to launch, you're hoping to "go viral," or you're about to drop marketing copy into a room that eats marketing copy for breakfast.

The core idea

The bar is usefulness + honesty, not polish. Developers will test your claims and read your code. Show up as a real engineer sharing real work, be present to answer everything, and never, ever fake it. One genuine launch beats ten hype posts.

First, learn from launches like yours

Before you pick a venue, read "How comparable products launched" in docs/gtm-cofounder/market-research.md (run research-the-market if it's missing). Where did products like yours launch, what got upvoted, and what got flamed in the comments? Not every dev tool belongs on Product Hunt, and some belong in a single niche community long before HN. Let the evidence pick the rooms, then use the anatomy below for each one.

Framework: Show HN anatomy (Czakon / Tailscale lessons)

  1. Title: plain, specific, zero hype. "Show HN: A faster Postgres migration tool for large tables", not "🚀 The future of database migrations is HERE."
  2. First comment = the story (post it yourself, immediately):
    • why you built it (the itch, ideally your own),
    • how it works (technical, concrete),
    • what's genuinely hard/limited right now (honesty buys trust),
    • a dead-simple way to try it.
  3. Be present for hours. Answer every comment, especially the critical ones, technically and without defensiveness. The comment thread is the launch.
  4. Never astroturf. No vote rings, no sock puppets. Communities detect it and the ban is permanent and public.

Framework: Product Hunt anatomy (fmerian / Kilo lessons)

  1. Name of the product: simply the name of your product in 40 characters or less.
  2. Tagline: concise and descriptive, in less than 60 characters. The most important part, the first thing people read on the front page. Avoid hyperbolic words and emojis. Keep it simple and relatable.
  3. Description: a short description of what the product does in less than 500 characters.
  4. Launch tags: up to three tags.
  5. Thumbnail: a 240 x 240 pixel thumbnail.
  6. Image gallery: at least 3 images to show your product. No stock images, no marketing fluff. Show the product, i.e. product screenshots. You can add social proof and a call-to-action to inspire action. The first image is used as the social preview when you share the link to your launch page.
  7. First comment: essential to get the discussion started. This comment is posted upon launch. The first 800 characters are displayed. Pro tip: reuse your HN comment.
  8. Be present for the first 4 hours. Upvote and reply to every comment. Don't just thank. Ask questions, inspire action.
  9. Find a hunter: an established Product Hunt user who can boost your reach. If you're in dev tools, Flo Merian (@fmerian) is a great one to ask. PH has dialed down hunter influence over time, so a strong launch and a present founder matter most, but a well-connected hunter still helps.

Framework adapted from Flo Merian's awesome-product-hunt.

Reddit / community launches

  • Give before you take. Be a real participant for weeks before you post your thing.
  • Read the rules of the specific subreddit; many ban self-promo outright, so find the ones that don't.
  • Frame as "I made this to solve X, feedback welcome," not a pitch.

The coordinated moment (not spam)

A launch is one prepared moment across the channels your ICP actually uses (named in market-research.md and chosen in first-50-users): HN, your own network, and the specific communities and newsletters your ICP reads, all on the same day, each tailored to the room and its self-promo rules. It is not the same copy blasted five places.

Decision tree: are you ready to launch?

Can a stranger get to first value in < 1 hour from docs alone (the weekend test)?
├─ NO  → don't launch yet. A flood of users who bounce burns the channel and the goodwill.
└─ YES → is your Show HN first-comment written (why/how/limits/try)?
         ├─ NO → write it first; it matters more than the product page.
         └─ YES → launch on a Tue-Thu morning US time, then clear your calendar to reply.

Mistakes that look reasonable

  • Hype title: emojis and superlatives on HN get flagged to death.
  • Absent founder: posting then leaving; the unanswered thread dies.
  • Defensive replies: arguing with critics. Thank them, concede the fair points, note what you'll fix.
  • Astroturfing: instant, permanent reputational damage.
  • Launching too early: before the weekend test passes, a launch amplifies your weakest moment.

Your next 30 minutes

  • Draft your Show HN title, plain, specific, no hype. Say it out loud; if it sounds like an ad, redo it.
  • Write the first comment: why · how · what's hard · how to try. This is the real work.
  • Confirm the weekend test passes (see know-if-its-working). If not, delay.
  • Pick the ONE day, block 4 hours to reply, and line up the 2-3 rooms your ICP is actually in, by name, from market-research.md.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). A launch you only get one shot at is worth a human sanity-check first. Reach out to me on LinkedIn.

Market to devs, sell to buyers

The developer who adopts your tool is almost never the person who pays for it. Win the developer's heart; then hand them the ammunition to win the budget conversation for you.

Use this when: you have stars, signups, and a beloved free tier, and a revenue line of zero.

The core idea (Czakon)

Market to developers, sell to decision-makers. Developers evaluate and adopt; buyers (CTO/VP/procurement) approve money. Your growth engine is the developer champion who sells internally, so your job is to make them look smart to their boss.

Framework: GTM models that work (Czakon)

Pick the one that fits your product and ICP; don't run all four half-heartedly.

ModelFits whenThe motion
Open sourceinfra/dev-tool, trust & inspectability matterOSS core → adoption → paid cloud/enterprise
PLG / self-servefast time-to-value, dev = buyer for small teamsfree tier → usage → expand → sales-assist on big accounts
Inboundyou can own the problem's content/SEOeducate on the problem → capture → nurture
Sales-led / ABMhigh ACV, complex enterprise, few big logostarget named accounts, land via a dev champion

Most dev tools are PLG + a sales-assist overlay for the accounts worth a human.

Framework: enable the champion (Czakon + Frankl)

Give the developer what they need to sell up:

  • The Kairos case for their boss (weeks off a release cycle, risk reduced), see value-prop-that-converts.
  • A one-pager / ROI snippet they can paste into an internal thread.
  • Security/compliance answers the buyer will ask (SOC 2, data handling), the CTO's real fears.
  • Proof: attributed results from peers at comparable companies.

Persona → sale map (Frankl): Alpha Dev finds & advocates → VPE/SRE validate feasibility → Empowered CTO approves budget → procurement handles terms (late, enterprise only). A complex sale needs a "what's in it for me" for each. Nail one persona and you get great meetings and no decisions.

Decision tree: when to introduce paid

Has the developer hit real, repeated value (Activation)?
├─ NO  → too early. Gating now kills adoption. Keep delivering value.
└─ YES → is this a small team (dev controls spend)?
         ├─ YES → self-serve upgrade in-product; keep it frictionless.
         └─ NO  → trigger sales-assist: help the champion build the internal case.

Close your first $1M yourself. Don't hand off sales before you've done it. Teaching a rep is far harder than teaching a founder who's felt the objections firsthand (Frankl).

Mistakes that look reasonable

  • Expecting developers to have budget: the Alpha Dev loves you and cannot pay you.
  • Gating value too early: a paywall before the aha moment converts curiosity into a bounce.
  • Cold-selling the VP: bypassing the champion; the buyer trusts their engineer, not your email.
  • No champion enablement: the developer wants to buy but has nothing to bring to their boss.
  • Four GTM models at 10% each: pick one primary motion and commit.

Your next 30 minutes

  • Name your model (OSS / PLG / inbound / sales-led) and the one you'll commit to first.
  • Identify your happiest free user → that's a champion. Ask what their boss would need to approve budget.
  • Build the champion's one-pager: Kairos case + proof + security answers.
  • Define the Activation moment that must happen before you ever mention paid.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). Choosing a GTM model is a bet you live with for years. If you want to talk it through, reach out to me on LinkedIn.

Pricing (what to charge, and how)

Price is not a number you pick at the end. It is a positioning decision: it tells the market who you are, what you replace, and how much you believe you are worth. Get it from evidence, not fear.

Use this when: you are guessing at a price, you priced on a gut feeling and now feel stuck with it, you don't know where the free line goes, developers use it and nobody pays, or you believe "developers won't pay for this" so you have never charged at all.

The core idea

Three decisions, in order. Most founders skip to the third and wonder why nothing converts.

  1. The value metric (what you charge per). The single most important pricing decision. Get this wrong and no tier structure saves you.
  2. The packaging (what is free, what is paid, what is enterprise, and what triggers the upgrade).
  3. The number (the actual price on each tier).

One rule sits under all of it: price against the value the customer gets, never against your cost or your fear. Your AWS bill is not a pricing strategy.

First: are you even ready to price?

Do not gate before you have proof people come back. If week-2 retention is weak, a paywall just turns a leaky funnel into a smaller leaky funnel. Prove retention, then monetize (see know-if-its-working). The one exception: if buyers are already emailing "can we pay you for X," that is a green light regardless of stage. Stated willingness to pay is the strongest signal there is.

Framework: the value metric

Charge for the thing that grows as the customer gets more value. A good metric:

  • Scales with their success, so the bill grows as they grow (seats, active users, projects, events, API calls, GB, builds, endpoints monitored).
  • Stays predictable enough that finance can forecast it. Pure usage that spikes 10x overnight creates bill shock and churn.
  • Is legible in one sentence. If a dev cannot predict roughly what they will pay, they will not adopt.
Does the value come mostly from more PEOPLE using it (collaboration, seats)?
├─ YES → per-seat, but watch for seat-sharing and bot accounts deflating it
└─ NO  → value comes from more USAGE (events, calls, compute, data)
         → usage-based, with a floor and caps so the bill stays predictable

Hybrid is common and fine: a platform fee plus usage. Avoid per-seat when the value is machine or usage driven (you tax the thing you want more of), and avoid pure usage when the value is human collaboration (you make teams ration access).

Framework: packaging (the free-to-paid line)

For an OSS or PLG dev tool, the free tier is acquisition, not charity. The line is not "how much can I give away," it is "what does a serious team need that a solo hacker does not."

  • Free / open source: the core value, for one developer or a tiny team. Generous enough to become part of their workflow. This is your distribution.
  • Paid (team): the things that appear the moment it matters to a company, not a person: collaboration and seats, higher limits and scale, SSO, audit logs, roles, compliance (SOC 2, on-prem, data residency), support and SLAs.
  • Enterprise: "contact us." Starts wherever security review, procurement, and custom terms enter, usually the moment someone asks for SSO or a DPA.

The upgrade should trigger at a moment of earned value, not an arbitrary wall. Good: "you added your third teammate," "you crossed 10k events," "you need SSO." Bad: a countdown timer, or hiding a feature the tool is useless without.

Rule of thumb: charge for team, scale, and trust. Give away individual value. Developers forgive a paywall on "my company needs this." They resent one on "the thing you advertised."

Framework: finding the number

Never pick it in a conference room. In order of strength:

  1. Deflected willingness to pay. The "can we pay for X" messages you have already received. Reply and ask: what was the cost of not having it, and what would it need to be to get approved internally? Free, and the highest-signal pricing research that exists.
  2. Value anchoring. Price against what you replace and what you save. Save a team 10 hours a month at a loaded $100/hr and that is $1,000 of value; charging $50 leaves the room. Capture a slice of value delivered, do not undercut a rival.
  3. Competitor anchoring. Know the number already in the buyer's head. If they compare you to a $30/mo tool, you need a reason to be $99, or a reason to be $9. Both can win. "Roughly the same but a bit cheaper" loses.
  4. The range question (in talk-to-users calls): "At what price would this be so expensive you would not consider it? At what price would it be so cheap you would doubt the quality?" The gap between the two is your range.

Thresholds worth knowing:

  • If nobody ever pushes back on price, you are too cheap. A healthy amount of "that is a lot" is correct.
  • Aim for the customer to get roughly 10x the price in value. Below about 3x, they churn; the math does not survive a budget review.
  • Annual is about two months free (15 to 20 percent off). It buys cash and retention.
  • Anchor high. Show the expensive tier so the one you want looks reasonable. Three tiers convert better than two, and the middle is usually the target.
  • Free-to-paid conversion of 2 to 5 percent is normal for OSS/PLG. Near zero usually means the free-to-paid line is wrong, not the price.

Mistakes that look reasonable

  • Cost-plus pricing. "It costs me $8 in compute so I will charge $12." Cost is a floor, not a strategy. Price the value.
  • Never charging. "Developers won't pay" is almost always "I have not asked, and I am scared to." The deflected-payment emails already disprove it.
  • Too many tiers. Four or more creates decision paralysis. Three is the ceiling for self-serve.
  • A free tier that is too generous. If a real company never needs to upgrade, you built a great free tool and no business. Move the line to team, scale, and compliance.
  • Per-seat on a machine-value product (or usage on a collaboration product). You end up taxing the exact behavior you want more of.
  • Competing on price. "Best value" and "cheaper than X" are a race to the bottom, and by the puffery rule, unprovable. Win on the value metric and the wedge, not the discount.
  • Fear-driven discounting. Caving at the first "too expensive" trains every buyer to push and signals you do not believe your own value.
  • Publishing usage pricing with no cap. Predictability beats a low headline rate. Bill shock is the top churn driver for usage models.

Your next 30 minutes

  • Name your value metric in one sentence: "we charge per ___." Check that it grows with the customer's success and stays predictable.
  • Draw the free-to-paid line: what a solo dev gets free vs what a company must pay for (seats, scale, SSO/compliance, support).
  • Find every "can we pay for X" message you have deflected. Draft the three-question reply (cost of not having it, shape of an approvable tier, rough budget).
  • Sketch three tiers (free/OSS, team, enterprise-contact-us) with one clear upgrade trigger between each.
  • Put a real number on the team tier, anchored to value, not cost. If it does not make you slightly nervous, it is too low.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). Pricing is the highest-leverage number you'll set, and the easiest to get wrong alone. Want a human read? Reach out to me on LinkedIn.

Founder-led sales (close your first customers yourself)

Nobody can sell it before you can. The first ten deals are not a hire, they are how you learn what you are actually selling and to whom. Do them yourself, badly at first, until the motion repeats.

Use this when: developers love it and live in the free tier but nobody pays, you have never sold anything and freeze on the actual conversation, every deal dies on "let me think about it," or you are tempted to hire a salesperson to do the part you have not figured out yet.

The core idea

market-to-devs-sell-to-buyers told you who to sell to (the dev adopts, the boss pays). pricing set the number. This is the part nobody warns technical founders about: actually doing it. And it is not slimy. Selling a dev tool well is discovery plus helping a champion get budget. You are not convincing anyone of anything false, you are finding the people who already have the pain and making it easy for them to say yes.

One rule under all of it: do this yourself until it repeats. You cannot outsource a motion you have not cracked. Founders who hire a rep at deal one hire someone to fail at a job that does not exist yet.

Every real deal has four things

If any one is missing, it is not a deal, it is a conversation. Your job is to find out which is missing.

  • A champion. Someone who uses it, loves it, and will fight for it inside their company. Usually the developer who adopted you.
  • A buyer. Someone with budget. Often not the champion.
  • A pain with a cost. Not "this is nice." A problem costing them money, time, or risk right now.
  • A trigger. A reason to act now, not next quarter. An incident, an audit, a deadline, a scaling wall.

The motion

1. Start with who is already engaged. Do not cold-blast strangers. Your first customers are hiding in your own usage data: the team with three seats on the free tier, the person who filed four issues, the account that hit a limit. They have already shown you the pain.

2. Reach out like a founder, not a sequence. One short, human message to a real person about a specific thing you noticed. If it could have gone to a thousand people, do not send it.

3. The first call is discovery, not a pitch. Talk 30 percent, listen 70. Learn: what are they using it for, what did they do before, what is the pain costing them, who else feels it, who owns the budget. Founders pitch too early and too much. The person asking the best questions controls the conversation.

4. Demo their use case, not your feature list. Show the product doing their job with their kind of data, and get them to the win (see time-to-first-value). A feature tour is not a demo. "Here is your exact problem, solved" is.

5. Frame value for the buyer, not the dev. The developer feels the hours saved (Chronos). The buyer approves budget for the outcome: a release cycle back, an incident avoided, a compliance box checked, a competitor not winning (Kairos). Translate the dev's love into a business result the boss can defend.

6. Arm the champion to sell internally. You are rarely in the room when the yes happens. Give your champion the one-paragraph business case, the number, and the answer to "why now," so they can walk it to their boss. This is the middle-out motion: an excited dev plus a buyer who sees the ROI.

7. Always leave with a specific next step and a date. This is how you kill the stall before it starts.

"Let me think about it" is not an objection

It is a missing next step, or a concern you did not surface. Do not accept it and leave. Ask, gently: "Totally fair. What would you need to be sure of to move forward?" Then you learn the real blocker (budget, a stakeholder, a missing feature, timing) and can actually address it. A vague yes-later is a no you have not diagnosed.

Thresholds worth knowing

  • Do it yourself through roughly your first 10 to 20 paying customers, or until you can write down what works and repeat it. Only then does hiring make sense.
  • Multithread. A deal with only the champion is fragile. If you have not spoken to the person with budget, you do not have a deal, you have a fan.
  • No next step, no deal. Never end a sales conversation without a specific action and a date.
  • Do not discount out of fear. Price pushback is a conversation about value, not a reason to cave (see pricing).
  • Talk less. If you are talking more than the customer in discovery, you are pitching, not selling.

Mistakes that look reasonable

  • Hiring a salesperson too early. You cannot delegate a motion you have not figured out. The first deals teach you what you are selling.
  • Pitching instead of asking. Founders lead with the product. The best sellers lead with questions and let the customer talk themselves into it.
  • Selling to the champion and stopping there. They love it and cannot sign. You have to reach the buyer.
  • Feature-touring the demo. Showing everything shows nothing. Show their problem solved.
  • Treating "think about it" as a yes. It is an undiagnosed no. Surface the real blocker before you leave.
  • Confusing usage with revenue. Ten thousand free users and zero conversations with a buyer is not traction, it is a popular free tier.
  • Apologizing for charging. If it delivers value, the price is fair. A founder who flinches on price trains the buyer to flinch back.

Your next 30 minutes

  • Open your usage data. List the 5 most engaged accounts (most seats, most usage, most issues filed). Those are your first sales calls.
  • For your best one, fill in the four: champion, buyer, pain-with-a-cost, trigger. Note which is missing.
  • Write one short, human outreach message to that champion about a specific thing you noticed. No template.
  • Draft five discovery questions you will ask before you show anything.
  • Decide the one business outcome the buyer would pay for, and say it in a single sentence.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If deals keep stalling and you want someone in your corner on the actual calls, reach out to me on LinkedIn.

Founder-led content

You don't have to "do marketing." You have to become the person developers trust on the problem. Sell the category, not the product, and let the authority pull people in.

Use this when: content feels slimy so you avoid it, your "blog" is a changelog, or a competitor is quietly becoming the go-to voice while you ship in silence.

The core idea

Developers reward technical depth, honesty, and a real point of view, and punish polished fluff. The move isn't promotion; it's education. Be the trusted expert on the problem, take a stance on where the space is heading, and the product sells itself as the obvious answer.

Before product-market fit, only the founder can do this. It's the #2 hire (DevRel) later, not now.

Framework: authority positioning (Frankl)

  • Own the problem, not just the product page. Talks, posts, teardowns, a distinctive thesis.
  • Sell the category: teach the problem, describe the need for "a tool like this," share results, without proactively pitching (that trips developer defenses).
  • Have an actual point of view on where the industry is going. A trusted expert has opinions; a vendor has features.

The "O'Reilly book" content plan (Frankl): imagine the definitive book on your problem, ~10 chapters, ~10 sections each. That's ~100 genuinely useful pieces mapped out. Publish against the outline consistently. You're writing the book that makes you the authority.

Framework: content & GitHub as distribution (Czakon)

  • Teach the problem space (DigitalOcean model): tutorials and deep dives that are useful even if the reader never buys. Curiosity-feeding > promotional.
  • README = your real landing page for an OSS/dev tool: what it is (one line) → why it exists → quickstart in <5 min → a copy-pasteable example → badges/social proof. A developer decides from the README, not your website.
  • Repo SEO: put the actual search terms in the repo name, description, and topics; developers (and Google) find repos by problem keywords.
  • Authenticity over polish: first-person, real, transparent. A rough honest post beats a glossy empty one.

Decision tree: what to write next

Do you have a real, contrarian-but-true opinion about your problem space?
├─ YES → write that. POV posts build authority fastest.
└─ NO  → write the tutorial you wish existed when you hit this problem.
         (Useful-to-a-stranger is the bar. If it only helps someone who already bought, rewrite it.)

Mistakes that look reasonable

  • Changelog-as-content: "we shipped X" is not a story or a draw (Frankl: a feature isn't news; a customer win is).
  • "Pleased to announce": nobody cares how you feel about your release.
  • Polish over substance: developers smell marketing and leave.
  • Neglecting the README: a great product with a lazy README converts nobody.
  • Inconsistency: three posts then silence. Cadence you can sustain beats a heroic burst.

Your next 30 minutes

  • Sketch your "O'Reilly book" outline: 10 chapters on your problem. You now have a content roadmap.
  • Write one POV sentence you actually believe about where your space is going.
  • Audit your README against the anatomy above (what · why · <5-min quickstart · example · proof).
  • Put your problem's real keywords into the repo name, description, and topics.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If you want help finding your angle and a cadence you'll actually keep, reach out to me on LinkedIn.

Know if it's working

The only early metric that matters is net developer retention. Without it, you're not running a funnel; you're running a colander.

Use this when: you're tracking GitHub stars and pageviews and still can't answer "is GTM working?", or you're pouring effort into acquisition while new users quietly churn.

The core idea

Acquisition is worthless if users don't come back. Prove retention first; only then does spending on acquisition make sense. Most early founders optimize the top of the funnel while the bottom leaks. Fix that order.

Framework: net developer retention (Frankl)

Of all the developers who first used the product in Month 1, how many used it in Month 2? Month 3?

  • Hold it above 100% (meaning existing cohorts grow through internal referral/expansion).
  • Below solid retention, do not focus on acquisition: you're filling a leaky bucket.
  • This single cohort question tells you more than every vanity chart combined.

Framework: the DREAM metrics (Frankl)

Measure one honest number per stage, not pageviews, not stars.

StageThe metric that counts
Discoveryunique human visitors / month
Researchnewsletter subs + community joins + follows
Evaluationfree-tier signups / downloads / active free users
Activationmonthly active users · frequency · session depth
Membershipcommunity members actively posting & answering

The gate before all of it, the weekend test: can a new developer get to first value over a weekend from docs + Stack Overflow, no support call? Time-to-value target: < 1 hour ideal, 1 day max. If Evaluation/Activation fails here, no channel work will save you.

Growth benchmarks (non-ARR, Frankl)

  • Pre-seed: ~30% month-over-month user growth
  • Post-Series-A: ~10% MoM
  • First $1M ARR: within 12 months is good, 9 is excellent

Framework: attribution philosophy (Czakon)

Developer marketing is hard to attribute and that's normal. A dev sees your HN post, reads a tutorial, lurks for two months, then signs up direct.

  • Don't over-trust last-touch; it will tell you "direct/organic" and hide the real work.
  • Add a "how did you hear about us?" free-text field. Self-reported attribution beats a broken model.
  • Judge channels on trend and directional signal, not spurious precision.

Decision tree: what to fix first

Is month-2 cohort retention healthy (users come back)?
├─ NO  → STOP optimizing acquisition. Fix Evaluation/Activation (the weekend test, time-to-value).
└─ YES → is a channel reliably producing retained users?
         ├─ YES → pour more in (and only now consider paid to amplify).
         └─ NO  → go back to first-50-users; find the channel before scaling spend.

Mistakes that look reasonable

  • Vanity metrics: stars, pageviews, impressions. They feel like progress and predict nothing.
  • Acquisition over a leaky bucket: buying users who never return.
  • Demanding clean attribution: chasing a perfect model instead of acting on directional signal.
  • Ignoring the weekend test: a beautiful funnel that dies at first-value.

Your next 30 minutes

  • Compute one number: of the devs who first used it 8 weeks ago, what % used it in the last 2 weeks?
  • Pick one honest metric per DREAM stage; delete the vanity charts from your dashboard.
  • Time yourself doing your own onboarding cold. Over an hour? That's your #1 GTM problem.
  • Add a "how did you hear about us?" field to signup this week.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If your numbers are telling a story you can't read, get a human to look with you. Reach out to me on LinkedIn.

Market scan (keep your read current)

Positioning rots. The competitor you sized up six months ago has since rebranded, raised, repriced, or renamed the category. This is the habit that keeps your brief honest about the world outside it.

Use this when: a rival just rebranded or repositioned, a new tool is getting attention in your space, your docs/gtm-cofounder/founder-brief.md competitor answers are more than a quarter old, or you just have the feeling the ground moved and your messaging is answering last year's market.

The core idea

research-the-market is the first full pass on the market: venues, launches, the problem in public, rivals, openings. This skill is the refresh after that, focused on what changed.

Your docs/gtm-cofounder/founder-brief.md captured the market as it was the day you wrote it. Markets don't hold still. A scan re-checks the outside world against your brief and surfaces the deltas: what changed, and which changes actually threaten or help your positioning. Most don't matter. The scan's job is to find the two or three that do, not to produce a competitor spreadsheet.

Before you start: can your agent see the web?

  • If your agent can browse or search the web, it runs the scan for real: competitor homepages, changelogs, pricing pages, launch posts, and recent discussion.
  • If it can't, it runs the scan as an interview: it asks what you've noticed and where, and you paste in the pages. Same output, you're the browser. Say which mode you're in up front.

How to run this (for the agent)

  • Start from the brief. Read docs/gtm-cofounder/founder-brief.md: the rivals ("what do they use instead"), the "why you", the villain, and the current positioning line. That's your baseline to compare against.
  • Scan the named rivals first, then the category. For each competitor in the brief, check: homepage headline and positioning, pricing, any rebrand or renamed category, funding or acquisition, and new capabilities that erase the founder's wedge. Then scan for new entrants and category-level shifts (a term everyone suddenly uses, a platform move, an AI or agent shift).
  • Report deltas, not descriptions. Do not summarize each competitor. Say what changed since the brief, and for each change, whether it strengthens, threatens, or is irrelevant to the founder's positioning. Rank by "does this move our position."
  • Tie every real change to an action. A rival adopting the founder's language means the wedge is eroding: route to positioning-and-story. A new pricing norm means revisit market-to-devs-sell-to-buyers. A dead competitor means an opening. No action, no reason to flag it.
  • Update the brief and roadmap. Rewrite the affected lines in docs/gtm-cofounder/founder-brief.md (rivals, why-you, villain, positioning) with today's reality and the date, and add any positioning move it triggers to docs/gtm-cofounder/gtm-roadmap.md. Keep the tags honest: a competitor's public claim is [assumption] until you have checked it is real.

What actually matters (and what doesn't)

Changes worth acting on:

  • A rival repositions onto your wedge or adopts your vocabulary. Your differentiation is eroding. Highest priority.
  • A new entrant is getting real traction in your exact lane.
  • The category gets renamed (buyers now search a different term than your copy uses).
  • A pricing norm shifts (a free tier appears or disappears, seat pricing becomes standard).

Noise to ignore:

  • Cosmetic rebrands, new logos, homepage redesigns with the same substance.
  • Feature announcements that don't touch your wedge.
  • Funding rounds that don't change what the product is or who it is for.

Mistakes that look reasonable

  • Reacting to a competitor's launch by copying it. Their move fits their strategy, not yours. Ask what it means for your wedge, not how to match it.
  • Scanning everything, changing nothing. A scan that doesn't update the brief or the roadmap was just anxiety with extra steps.
  • Treating a rival's marketing claim as fact. "Now with X" on a homepage is a positioning bet, not proof it works. Tag it [assumption].
  • Doing it constantly. Monthly, or on a real trigger (a rebrand, a new entrant), is plenty. Daily competitor-watching is procrastination dressed as diligence.

Your next 30 minutes

  • Tell your agent which mode you're in (it browses, or you paste).
  • List the rivals from your docs/gtm-cofounder/founder-brief.md. Scan each for a rebrand, repricing, or repositioning since you wrote it.
  • Write down only the changes that touch your wedge. Ignore the cosmetic ones.
  • For each real change, mark it strengthens / threatens / irrelevant, and the one action it triggers.
  • Update the affected lines in docs/gtm-cofounder/founder-brief.md (with the date) and add any positioning move to docs/gtm-cofounder/gtm-roadmap.md.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If the market has shifted under you and you're not sure what it means for positioning, reach out to me on LinkedIn.

Review the work (the self-check gate)

The person who wrote it is the worst judge of whether it is good. Before this reaches the founder, stop being the author and become the skeptic.

Use this when: you are about to present any substantive deliverable, or the founder asks "is this actually good?" It is a gate, not a stage. It has no place in the linear sequence. Run it around any piece of work, every time.

The core idea

An agent that just wrote something is biased to ship it. That bias is how generic, plausible, quietly wrong work reaches a founder who does not yet know enough to catch it. So separate the two jobs: the author drafts, a different lens judges. You do not present work because you made it. You present it because it survived a skeptic.

Steal the one rule that makes this work: the author may submit the work, the author may not issue the verdict. Switch roles on purpose. Become the developer who is skeptical, the buyer who is busy, the reviewer who has seen a hundred of these, and try to break it before the market does.

How to run this (for the agent)

  • Run it silently, before presenting. The founder should see the verdict and the work, not the whole audit.
  • Give a clear verdict: PASS, or REVISE with the exact checks that failed and the specific fix for each. Never a vague "looks good."
  • Do not rubber-stamp. If you cannot find a single weakness, you are not reading as the skeptic. Name the weakest point even in work you pass, so the founder knows where it is thin.
  • When it fails, fix it and re-run the gate, then present. Do not hand the founder a list of problems you could have fixed yourself.

The standard (applies to everything)

  • Specific, not puffery. No "powerful," "seamless," "best-in-class," "platform." Every claim carries a number, a name, or a proof, or it gets cut.
  • The developer is the hero, not the product. If the founder's tool is the hero of the sentence, rewrite it.
  • It speaks to the real ICP from the brief, not to "developers." A message for everyone lands on no one.
  • It rests on validated facts. Anything load-bearing that is still [assumption] is flagged out loud, not smuggled in as truth.
  • Every outside fact is real and linked. A community, a member count, a launch result, a quote: each one has a link you actually checked. If you can't point to the source, cut it or mark it unknown. An invented fact the founder acts on is the worst failure in this pack.
  • A skeptical developer could not immediately prove it false. Developers test claims and find the truth. If a dev would find the failing case in thirty seconds, you have not passed.
  • Human voice. Reads like a person wrote it. No em-dashes, no AI tells.

The specific checks (by deliverable)

Run the general standard, then the relevant skill's own checklist:

  • Positioning / story (positioning-and-story): problem-first, not solution-first. Has a villain. Survives the "every competitor could say this" test.
  • Value prop (value-prop-that-converts): no banned words, built on a real job-to-be-done, and a developer would repeat it in their own words.
  • Homepage (the-homepage): written for the developer who visits, not the buyer who never does. Time to first value is obvious.
  • Launch post (launch-it): honest, not salesy. Opens on the developer's problem, not the product. Would not get flamed for overclaiming.
  • Pricing (pricing): anchored to a value metric, not a guessed number. The buyer could justify it to whoever holds the budget.
  • Founder-led sales (founder-led-sales): passes the four-part deal test. Does not mistake a friendly free user for a buyer.
  • The brief (start-here): strongest asset at the top, [validated] / [assumption] tags intact, in the founder's own words.
  • The market research (research-the-market): leads with what the founder didn't say. Venues are named and linked, ranked by fit not size, with self-promo rules noted. Nothing is filled in from memory.
  • The roadmap (strategy-and-roadmap): opens with a one-line Diagnosis, then What the research added, then Now / Next / Later. It is a plan, not a re-saved copy of the brief. The founder-facing test: would they read it and learn something they didn't tell you? If every move traces back to their own answers, it fails. Channel and launch moves name specific venues, not categories.

Your next 30 minutes

  • Take the last thing produced (a headline, a post, a price) and run it through the standard above, as the skeptic, not the author.
  • Name the single weakest claim in it. Replace it with something provable, or cut it.
  • Find the one [assumption] it depends on most, and decide whether it is safe to ship on or belongs in talk-to-users first.
  • Only then put it in front of a real person. If it did not survive you, it will not survive them.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). Want an independent human read before this goes live? That's exactly what I do. Reach out to me on LinkedIn.

Growth loops (the next 5,000 without you)

You got your first 50 users by hand: DMs, favors, one good launch. That was the right way to get them, and it was never supposed to scale. A growth loop is what comes next: one user's ordinary use of the product exposes it to the next user, and that user repeats it. Not a one-time referral; a continuous cycle.

Use this when: growth flatlines every time you stop posting, you can trace every user to a founder DM or a launch day, or you're about to add a third channel when the users you already have produce zero new ones.

The core idea

A channel is linear: effort in, users out, stop pushing and it stops. A loop feeds output back into input: usage creates an artifact, a public trace, or an invitation that a new developer finds, and that developer's usage restarts the cycle. Channels deplete; loops compound.

The rule that keeps it non-slimy: every loop must do the user a service, not just you. A branded report the user is proud to send is a loop; a watermark they resent is spam with extra steps. If the loop degrades the experience, it is not a loop, it is a leak in your trust.

The gate: a loop amplifies whatever you feed it. If week-2 retention is broken, a loop compounds churn, not growth. Before this skill: first value in under an hour (time-to-first-value), first 50 real users in hand (first-50-users), and cohorts that come back (know-if-its-working, Frankl's net developer retention). If any of those fail, that failure is your Now move, not this.

The dev-tool loop catalog

Six loops that actually work for developer tools. You need one, running at full strength.

  1. Showcase loop. The product's output is shareable and carries your name with it: a CodePen link, an exported report with the logo intact, a "Generated by X" footer on docs. crowd.dev's exported community health reports carried the branding; recipients asked how the report was made, and that question was the signup.
  2. Badge loop. A status signal developers want in their README: "build passing" (Travis CI, CircleCI), coverage percent (Codecov). Every visitor to every repo that uses you sees a micro-advertisement, and the badge earns its place by signaling quality, not by begging.
  3. Workflow loop. The tool acts inside a shared workflow where non-users see it working. Snyk auto-opens pull requests with vulnerability fixes; every collaborator reviews that PR, discovers the tool, and signs up. A bot comment on a fixed issue, a summary email a dev forwards to the team: same mechanics.
  4. Team loop. One developer adopts, and the tool lands in a shared repo, a CI pipeline, or a lockfile every collaborator now touches. Then it walks out the door when a dev changes jobs and installs it on day one. The qualifying question: does the tool become more useful when more people use it together? If yes, build the invite into onboarding, not into a popup.
  5. Public-content loop. Usage produces content strangers find: user-created projects and collections browsable in public (StackBlitz, Postman's public workspaces), community answers that stay indexed instead of dying in a ticket, and the tutorials their questions teach you to write (founder-led-content is this loop's fuel).
  6. Marketplace loop. Live where developers already shop: a VS Code extension, a Jenkins plugin, a framework's starter gallery, GitHub's own surfaces (trending, "used by", dependents). Every new user of their platform can now discover yours.

Decision tree: pick your one loop

Does normal use already produce something other developers can see
(an output, a badge, a PR, a config in a shared repo)?
├─ YES → showcase, badge, or workflow loop. Instrument what is
│         already happening before you build anything new. This is
│         the cheapest loop you will ever get.
└─ NO  → is the tool more useful when a team uses it together?
         ├─ YES → team loop: put the invite where the value is,
         │        not in a growth popup.
         └─ NO  → do developers search or ask in public when this
                  problem bites?
                  ├─ YES → public-content loop: answer and publish
                  │        where it gets indexed, every time.
                  └─ NO  → your ICP may be too diffuse to loop.
                           Tighten it in `who-is-this-for` first.

Measure the loop, not the traffic

One question, monthly: of your new signups, what share came from an action an existing user took (a badge click, a shared artifact, a fix PR, a committed config, an answered thread)?

  • Under 10%: you have channels, not a loop. Fine at 50 users, a problem at 500.
  • 30% and rising month over month: the loop is turning. Feed it before you add anything else.
  • Track cycle time too: a loop that takes two weeks per turn compounds; one that takes six months is a channel wearing a loop costume.
  • Attribution here is directional, not precise (Czakon): the free-text "how did you hear about us?" field is your honest instrument. Tag every answer loop or channel.

Mistakes that look reasonable

  • Building a loop on leaky retention. Amplifying a product people abandon just abandons faster. The gate is the gate.
  • Paid referral incentives for developers. "Give $20, get $20" reads as bribery to the exact audience that punishes it, and it poisons the genuine recommendations you already get. Devs refer because the tool made them look good, so make that effortless instead.
  • Forced virality. An unremovable badge or watermark gets stripped, resented, and posted about. Dual value or nothing: the loop must serve the user first, and stay deletable. The ones that remain are worth more.
  • Mistaking a launch spike for a loop. A launch is one crank of the handle (launch-it). The test is whether the users it brought produce users. If the graph decays back to baseline, it was a channel.
  • Running three loops at 30%. Each half-built loop below critical mass produces nothing. One loop compounding beats three leaking; add the second when the first runs without you.
  • Copying B2C mechanics. Waitlists, invite gates, and streaks signal "growth-hacked" to developers. The first rule still holds: don't lie to developers, they find out.

A worked example

Snyk's core loop is the workflow loop run to perfection: the product's normal job is opening pull requests that fix vulnerabilities. Every teammate who reviews one of those PRs sees the tool doing something undeniably useful, in their own repo, with zero pitch. The exposure is the value delivery; nothing was bolted on. Contrast the failure mode: a tool that appends "try X!" to commit messages delivers the exposure without the value, and gets uninstalled. Same surface, opposite outcome. The question to steal is not "where can I put my logo?" but "where does my product already do visible work a stranger would respect?"

Your next 30 minutes

  • Take your last 20 signups and sort them: founder action, launch spike, or existing-user action. Count the third pile honestly. That number is your baseline.
  • Walk the catalog and circle the ONE loop your product's normal use already half-performs. Don't invent; instrument.
  • Find the visible work your product already does that a stranger would respect, and make it carry a tasteful, removable link.
  • Confirm "how did you hear about us?" exists as free text (see know-if-its-working), and start tagging answers loop vs channel.
  • Check the gate: if week-2 retention is broken, park this skill and open time-to-first-value. Loops wait; churn doesn't.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). The loop catalog is adapted from Jonathan Reimer's Growing Developer Tools: A Handbook, with the loop model from Brian Balfour and Casey Winters (Reforge). If you're not sure which loop fits your product, or the one you built isn't compounding, reach out to me on LinkedIn.

Research the market (what you didn't tell me)

The brief is what you know. A plan built only from the brief can only rearrange your own answers back to you. This is the step where the agent goes out and finds what you don't know yet: where your users actually are, how products like yours got their first users, and the openings you haven't seen.

Use this when: you've just written the brief and want a plan grounded in the real market, not just your own read. Or you're about to pick channels or plan a launch and "post on Reddit and HN" is the best idea on the table. Or the roadmap you got back felt like a tidy summary of what you said.

The core idea

The interview pulls out what's in your head. Research brings in what isn't: the specific subreddit where your ICP complained about this exact problem last week, the newsletter they all read, the three products in your space that launched in the last two years and what actually brought their first users, the competitor you didn't name.

Research is planning-grade evidence, not proof. Public evidence that 40 people asked for this in a GitHub issue is strong enough to plan a channel around. It is not strong enough to call the pain validated or to set a price. So it gets its own tag, [researched], between [assumption] and [validated]. Only a real conversation with a real user who is not a friend earns [validated].

Before you start: can your agent see the web?

  • If your agent can browse or search the web, it runs the research for real, and every finding carries a link.
  • If it can't, it says so up front and hands you a short list of exact searches to run (8 to 12, each a copy-paste query with what to look for). You paste back what you find, and it does the analysis. Same output, you're the browser.

Never fake it. An agent without web access that writes up "communities" from memory is guessing, and invented member counts and dead links destroy trust fast.

How to run this (for the agent)

  • Start from the brief. Read docs/gtm-cofounder/founder-brief.md: the product, the ICP, the alternatives, the stage. That sets what to search for. Then go further than the brief, on purpose.
  • Check the ICP is concrete enough to research. "Developers" can't be researched; "platform engineers at 50 to 500 person companies running Kubernetes" can. If the ICP is vague, run the research anyway, but aim it at which segment shows the most pain in public, and hand that finding to who-is-this-for.
  • Every finding has a link and a date. No link, it doesn't go in. Never invent a community, a member count, a URL, a quote, or a launch result. If you can't verify a number, say "size unknown" rather than estimating.
  • Name venues, never categories. "Reddit" is not a finding. "r/devops, where three threads in the last month asked for exactly this" is.
  • Rank by fit, not size. A 4,000-member Discord where your ICP talks about the problem weekly beats a 2 million member subreddit where they never do. For each venue, record the evidence that your ICP is there talking about this problem.
  • Check the rules of the room. For every community, note whether it allows self-promotion, and how (a weekly thread, a flair, an outright ban). A channel that bans you on your first post is not a channel.
  • Keep it bounded. This is a sprint, not a thesis: roughly 20 to 40 searches, an hour of agent time at most. Stop when new searches stop changing the picture.
  • Lead with surprises. The most valuable part is what the founder didn't say. Put "What I found that you didn't tell me" at the top of the file, and flag anywhere the research disagrees with the brief (they said their users hang out on X, the evidence says Y).
  • Don't rewrite the brief yourself. Where the research contradicts or sharpens a brief answer, propose the change, and let the founder accept it. Accepted changes go into the brief tagged [researched] with the date.
  • Then hand off. If there's no roadmap yet, go to strategy-and-roadmap, which now has to use this file. Offer, never impose.

The five things to find

1. Where your ICP already sits (the watering holes)

Find the 5 to 10 specific places your ICP already goes to discover tools and talk shop. Ways in:

  • Search the problem in their words, plus "reddit", "discord", "slack", "forum". Note which rooms keep coming up.
  • Search Hacker News (site:news.ycombinator.com) for the category and the named alternatives. Who comments, and what do they ask for?
  • GitHub: topics, awesome-lists, and the issue trackers of the alternatives. An issue with 50 thumbs-up asking for what you built is a venue and a lead list.
  • Newsletters, podcasts, and YouTube channels covering the category. Who has the ICP's attention every week?
  • Where competitors show up: what they sponsor, which conferences they speak at, which communities their founders post in. Sponsorship spend is a public tell for where they believe the buyers are.
  • Integration marketplaces and ecosystems the product plugs into (VS Code, a framework's plugin directory, a cloud marketplace, a Slack app directory).

For each venue: name, link, size and activity signal (members, posts per week, last active), self-promo rules, and the evidence your ICP is there talking about this problem.

2. How comparable products launched

Find 3 to 5 products in or next to the category that launched in roughly the last three years. For each: where they launched (find the actual HN thread or Product Hunt page), how it went (points, rank, the top comments, what got praised and what got flamed), and what founders say brought their first users (search "how we got our first users", launch retrospectives, founder interviews and podcasts). Then name the pattern: what worked for products like this one, and what didn't.

3. The problem in strangers' own words

Collect 10 to 20 public posts where people describe the pain (forum threads, issues, HN comments, posts, reviews of the alternatives). Keep the link and a short fragment of their words. This list does three jobs: it's language for positioning-and-story, interview candidates for talk-to-users, and the first people to reach out to in first-50-users.

4. The rivals and alternatives you didn't name

Search for the products, open-source projects, and homegrown workarounds people actually use for this job, especially the ones missing from the brief. For each, one line: how they position and what they charge. Keep it light. Ongoing competitor tracking belongs to market-scan; this is the first full pass.

5. Openings

The outside-the-box part. From everything above, name the 3 to 5 openings the founder didn't bring: an underserved segment that shows up loud in the research, a venue no competitor is working, a marketplace or partner ecosystem to ride, a timely hook (a platform change, a deprecation, a pricing change by a big alternative, a conference coming up), a launch pattern that fits this product. Each opening cites the findings it rests on.

Decision tree: what to do first

Can the agent browse the web?
├─ NO  → hand the founder 8-12 exact searches, wait for the pastes, then analyze.
└─ YES → is the ICP concrete (role, company shape, technical context)?
         ├─ NO  → research which segment shows the most public pain,
         │         then route that finding to who-is-this-for.
         └─ YES → run all five, watering holes and comparable launches first.
                  Those two change the plan the most.

The research file

Save to docs/gtm-cofounder/market-research.md in the founder's project. Keep it scannable, links on everything, no em-dashes:

# Market research
Researched: <date> · Mode: web | founder-pasted

## What I found that you didn't tell me
- 3 to 5 bullets, the surprises and openings, each pointing to the evidence below.
- Where the research disagrees with the brief, say so here.

## Where your ICP sits (ranked by fit)
| Venue | Link | Size / activity | Self-promo rules | Evidence your ICP is there |

## How comparable products launched
- Product: where, how it went (link), what brought first users, the lesson.
- The pattern: ...

## The problem in their words
- "short fragment" (link, date)

## Rivals and alternatives
- Name (link): positioning in a line, pricing.

## Openings
1. Opening, why now, the evidence it rests on.

## Proposed brief changes
- Brief line → what the research suggests (for the founder to accept).

Mistakes that look reasonable

  • Categories instead of venues. "Developer communities and social media" is not research. If a line has no link, it's a guess.
  • Size over fit. Chasing the biggest subreddit because it's big. Your ICP has to be in the room, talking about your problem.
  • Inventing to fill gaps. A plausible member count or a remembered launch result that you didn't check is worse than "unknown". Founders act on these numbers.
  • Treating research as validation. Fifty people complaining in public tells you where to go and what to say. It doesn't tell you they'll switch, or pay. That still takes talk-to-users.
  • Copying a competitor's launch wholesale. Their launch fit their product, their audience, and their year. Take the pattern, not the playbook.
  • Researching instead of talking. Research is an hour, not a hiding place. If it's been a week of research and zero conversations, stop and go talk to the people on your list.

Your next 30 minutes

  • Tell your agent which mode you're in: it browses, or you paste.
  • Run the research and read "What I found that you didn't tell me" first.
  • Open the top three watering holes yourself. Do they feel like your people? Note any that don't.
  • Accept or reject the proposed brief changes.
  • Run strategy-and-roadmap so the plan is built on the brief and the research.

Built from real dev-tool GTM experience, with frameworks from Adam Frankl (The Developer-Facing Startup) and Jakub Czakon (markepear.dev). If the research turns up an opening you're not sure how to play, reach out to me on LinkedIn.

Sponsors

Details

Marketplace
AIDevGTM/gtm-cofounder
Category
Community