Skip to main content
ZICQ

Skills ZICQ category:Design gtm-developer-ecosystem

Gtm Developer Ecosystem

Build and scale developer-led adoption through ecosystem programs. Use when deciding open vs curated ecosystems, building developer programs, scaling platform adoption, or designing student program pipelines.

1543 installs

Official URL:skills.sh

What this skill does

Intro in this page language first. The official description stays in its original wording; we do not rewrite SKILL.md.

What it does

Build and scale developer-led adoption through ecosystem programs

When to use it

**Triggers:**

How agents load it

Per Agent Skills progressive disclosure: name and description load at startup (~100 tokens); the full SKILL.md body loads when the skill activates; scripts/, references/, and assets/ load only as needed. This file's sections: Developer Ecosystem; When to Use; Core Frameworks; 1. Open vs Curated Ecosystem (The Marketplace Decision); 2. The Three-Year Student Program Arc; 3. Developer Journey (Awareness → Integration → Advocacy).

File analysis

File analysis: instruction-only skill (SKILL.md). The agent loads the full body when activated.

Developer EcosystemWhen to UseCore Frameworks1. Open vs Curated Ecosystem (The Marketplace Decision)2. The Three-Year Student Program Arc3. Developer Journey (Awareness → Integration → Advocacy)4. Documentation Hierarchy5. Community vs Support (When to Use Which)6. Partner Tiering for Developer EcosystemsDecision TreesOpen or Curated Ecosystem?Community or Support?

· License:MIT

Source category:skills.sh agent-skill

SKILL.md & Agent activation

Official spec ↗
name
gtm-developer-ecosystem
description
Build and scale developer-led adoption through ecosystem programs. Use when deciding open vs curated ecosystems, building developer programs, scaling platform adoption, or designing student program pipelines.
License
MIT
  1. DiscoverThe client exposes names and descriptions to the agent.
  2. ActivateYour request or the task context selects the skill and loads its instructions.
  3. Load resourcesReferenced scripts, documentation and assets are used when needed.

Invocation syntax and available tools depend on your Agent client. Client integration guide ↗

Install this skill

Skills CLI ↗

Choose the target agent and installation scope, keep referenced package files, then verify the skill appears in the client's catalog.

Ask your Agent to install

Copy these instructions to a compatible agent and confirm the target directory matches your client.

Install the agent skill "gtm-developer-ecosystem" into my project. The full SKILL.md and official description are at https://zicq.com/en/skills/skl-b6be537f2fa86bcf-Gtm-Developer-Ecosystem.html
Save it as .cursor/skills/gtm-developer-ecosystem/SKILL.md or .claude/skills/gtm-developer-ecosystem/SKILL.md and keep the frontmatter name and description exactly as-is.

Full package on GitHub ↗

Install from the terminal · Skills CLI

Requires Node.js and npx. First inspect the repository's skill list to confirm the name.

npx skills add 'https://github.com/github/awesome-copilot' --list

npx skills add 'https://github.com/github/awesome-copilot' --skill 'gtm-developer-ecosystem'

The CLI lets you choose the agent interactively. The default scope is the project; use -g for user scope. Confirm package availability with the discovery command, then use npx skills list to inspect installed skills.

Readable layout

name: gtm-developer-ecosystem description: Build and scale developer-led adoption through ecosystem programs. Use when deciding open vs curated ecosystems, building developer programs, scaling platform adoption, or designing student program pipelines. license: MIT metadata: author: Smit Patel (https://linkedin.com/in/smitkpatel) source: https://github.com/beingsmit/technical-product-gtm

Developer Ecosystem

Build and scale developer-led adoption through ecosystem programs, community, and partnerships. Focus on what actually drives adoption, not vanity metrics.

When to Use

Triggers:

  • "How do we build a developer ecosystem?"
  • "Should we curate quality or go open?"
  • "Developer community isn't growing"
  • "Nobody's building on our API"
  • "How do we compete with larger platforms?"

Context:

  • API platforms and developer tools
  • Products with extensibility (plugins, integrations)
  • Developer-first GTM motion
  • Platform business models

Core Frameworks

1. Open vs Curated Ecosystem (The Marketplace Decision)

The Pattern:

Running ecosystem at a developer platform. Leadership debate: Open the marketplace to anyone, or curate for quality?

Quality control camp: "We need gatekeeping. Otherwise we'll get SEO spam, low-quality integrations, brand damage."

Open camp: "Developers route around gatekeepers. Network effects matter more than quality control."

The decision: Went open. Quality concerns were real, but we made a bet: control comes from discovery and trust layers, not submission gatekeeping.

What We Built Instead of Gatekeeping:

  1. Search and discovery — Surface high-quality integrations through algorithms, not human curation
  2. Trust signals — Verified badges, usage stats, health scores
  3. Community curation — User ratings, collections, recommendations
  4. Moderation — Remove spam after publication, not block before

Result: Network effects won. Thousands of integrations published. Quality surfaced through usage, not through us deciding upfront.

Decision Framework:

  • Curated works when: Brand risk high, dozens of partners, can scale human review
  • Open works when: Hundreds/thousands of potential partners, network effects matter more than quality control

Common Mistake:

Defaulting to curated because "we need quality control." This works when you have 10 partners. At 100+, you become the bottleneck. Build discovery and trust systems instead.


2. The Three-Year Student Program Arc

The Pattern:

Most developer programs optimize for quick wins. Better approach: Build long-term talent pipeline.

Year 1: University Partnerships

  • Partner with CS departments
  • Curriculum integration (hackathons, coursework)
  • Student licenses (free or heavily discounted)
  • Metrics: # universities, # students activated

Year 2: Student Community & Certification

  • Student expert certification program
  • Student-led workshops and events
  • Campus ambassadors
  • Metrics: # certified, # student-led events

Year 3: Career Bridge

  • Job board connecting students → companies
  • Enterprise partnerships (hire certified students)
  • Alumni network
  • Metrics: # hired, company partnerships

Why This Works:

Students become enterprise buyers 5-10 years later. You're building brand loyalty before they have purchasing power.

Common Mistake:

Treating students as immediate revenue. They're not. They're future enterprise decision-makers.


3. Developer Journey (Awareness → Integration → Advocacy)

Stage 1: Awareness

  • How do they discover you?
  • Content, search, word-of-mouth, events

Stage 2: Onboarding

  • First API call in <10 minutes
  • Quick-start guides
  • Sample code in popular languages

Stage 3: Integration

  • Building real use cases
  • Integration guides
  • Support when stuck

Stage 4: Production

  • Deployed and generating value
  • Monitoring usage
  • Enterprise upgrade path

Stage 5: Advocacy

  • Sharing publicly
  • Recommending to others
  • Contributing back (docs, code, community)

Metrics That Matter:

  • Time to first API call (onboarding)
  • % reaching production (integration success)
  • Monthly active developers (engagement)
  • Developer NPS (advocacy)

Common Mistake:

Measuring vanity metrics (sign-ups, downloads) instead of real engagement (API calls, production deployments).


4. Documentation Hierarchy

Tier 1: Quick Starts (Get to Value Fast)

  • "Hello World" in 5 minutes
  • Common use case examples
  • Copy-paste code that works

Tier 2: Guides (Solve Real Problems)

  • Use case-specific tutorials
  • Integration patterns
  • Best practices

Tier 3: Reference (Complete API Docs)

  • Every endpoint documented
  • Request/response examples
  • Error codes and handling

Tier 4: Conceptual (Understand the System)

  • Architecture overviews
  • Design philosophy
  • Advanced patterns

Most developers need: Tier 1 first, then Tier 2. Very few read Tier 4.

Common Mistake:

Starting with Tier 3 (comprehensive API reference). Developers want quick wins first.


5. Community vs Support (When to Use Which)

Community (Async, Scalable):

  • Slack/Discord for real-time help
  • Forum for searchable Q&A
  • GitHub discussions for feature requests
  • Best for: Common questions, peer-to-peer help

Support (Sync, Expensive):

  • Email support for enterprise
  • Dedicated Slack channels for partners
  • Video calls for complex integrations
  • Best for: Paying customers, strategic partners

How to Route:

Community first:

  • Developer asks question
  • Community member answers
  • You validate and upvote
  • Searchable for future developers

Escalate to support when:

  • No community answer in 24 hours
  • Enterprise/paying customer
  • Security or compliance issue
  • Complex integration requiring custom work

Common Mistake:

Providing white-glove support to everyone. Doesn't scale. Build community that helps itself.


6. Partner Tiering for Developer Ecosystems

Tier 1: Integration Partners (Self-Serve)

  • Build with public API
  • You provide: docs, Slack channel, office hours
  • They drive their own marketing
  • Best for: Ambitious partners with resources

Tier 2: Strategic Partners (Co-Development)

  • Co-developed integration
  • You provide: dedicated channel, co-marketing
  • Joint case studies
  • Best for: High-impact integrations

Don't over-tier. 2 tiers is enough. More creates confusion.


Decision Trees

Open or Curated Ecosystem?

Is brand damage risk high if low-quality partners join?
├─ Yes (regulated, security) → Curated
└─ No → Continue...
    │
    Can you scale human review?
    ├─ No (hundreds/thousands) → Open + discovery systems
    └─ Yes (dozens) → Curated

Community or Support?

Is this a common question?
├─ Yes → Community (forum, Slack, docs)
└─ No → Continue...
    │
    Is requester paying customer?
    ├─ Yes → Support (email, dedicated)
    └─ No → Community (with escalation path)

Common Mistakes

1. Building ecosystem before product-market fit

  • Fix core product first, then build ecosystem

2. No developer success team

  • Developers need help to succeed beyond docs

3. Poor documentation

  • Foundation of ecosystem, non-negotiable

4. Treating all developers equally

  • Tier support by strategic value (paying > free, partners > hobbyists)

5. No integration quality standards

  • Low-quality integrations hurt your brand

6. Measuring only vanity metrics

  • Track activation and production usage, not just sign-ups

7. Developer advocates with no technical depth

  • Hire developers who can code and teach

Quick Reference

Open ecosystem checklist:

  • [ ] Search and discovery (surface quality algorithmically)
  • [ ] Trust signals (verified badges, usage stats, ratings)
  • [ ] Community curation (user recommendations, collections)
  • [ ] Moderation (remove spam after publication)

Developer journey metrics:

  • Awareness: Traffic, sign-ups
  • Onboarding: Time to first API call (<10 min target)
  • Integration: % reaching production deployment
  • Advocacy: Developer NPS, public sharing

Documentation hierarchy:

  1. Quick starts (5-min "Hello World")
  2. Use case guides (solve real problems)
  3. API reference (complete documentation)
  4. Conceptual (architecture, philosophy)

Partner tiers:

  • Tier 1: Self-serve (public API, docs, community)
  • Tier 2: Strategic (co-development, co-marketing)

Student program timeline:

  • Year 1: University partnerships, activation
  • Year 2: Certification, student community
  • Year 3: Job board, enterprise hiring bridge

Related Skills

  • partnership-architecture: Partner deal structures and co-marketing
  • product-led-growth: Self-serve activation funnels for developer products
  • 0-to-1-launch: Launching developer products

Based on building developer ecosystems at multiple platform companies, including the open vs curated marketplace decision, student program development (3-year arc building talent pipeline), and partner ecosystem growth. Not theory — patterns from building developer ecosystems that actually drove platform adoption and multi-year brand loyalty.

Related skills

Design

Automation Workflows

Design and implement automation workflows to save time and scale operations as a solopreneur. Use when identifying repetitive tasks to autom…

Design

Ui Ux Pro Max

UI/UX design intelligence and implementation guidance for building polished interfaces. Use when the user asks for UI design, UX flows, info…

Design

Frontend Design

Expert frontend design guidelines for creating beautiful, modern UIs. Use when building landing pages, dashboards, or any user interface.

Design

N8n Workflow Automation

Designs and outputs n8n workflow JSON with robust triggers, idempotency, error handling, logging, retries, and human-in-the-loop review queu…