跳到正文
cccskills
免费在 GitHub 公开

gtm-developer-ecosystem

Plan programs that help developers adopt an API or platform. Compare open and curated ecosystems, map the developer journey, and organize documentation, community support, partnerships, and student programs around actual product usage.

中文简介正在准备中。当前显示英语简介。

原文查看原文说明

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.

集成工具Slack
查看安装方法

适用场景

  • Choosing an open or curated integration marketplace
  • Reviewing the journey from first API call to production
  • Defining community and paid support responsibilities
  • Planning a three-year student program

包含的文件(1)

  • SKILL.md9.1 KB

SKILL.md(原文)

安装前可以查看交给 AI 代理的指令内容。

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.

评价

还没有评价。欢迎分享你的使用感受。

评论

无需登录即可发表。欢迎分享使用感受、提问,或说明在哪些环境下无法运行。

还没有评论。来写第一条吧。

提交后会立即公开。请勿填写邮箱、电话等个人信息。URL 最多 2 个。

0 / 1000 字

此表单受 reCAPTCHA 保护,适用 Google 的隐私权政策和服务条款。

同一仓库的技能

Map an existing codebase into seven documents covering its technology, structure, architecture, conventions, integrations, tests, and concerns. Link findings to file evidence, mark unknowns, and highlight differences between stated plans and the actual implementation.

中文简介正在准备中。当前显示英语简介。

  • Get oriented in an unfamiliar codebase
  • Prepare documentation for a project handover
  • Compare documented architecture with implementation
github/awesome-copilot4万2026年10月17日 更新

Assess a repository’s readiness for AI agents with AgentRC and generate a standalone HTML dashboard. Review scores across nine areas, see prioritized improvements, and optionally apply scoring policies tailored to an organization.

中文简介正在准备中。当前显示英语简介。

  • Assessing a repository’s readiness for AI agents
  • Prioritizing improvements from assessment results
  • Reviewing scores under an organization’s own policy
github/awesome-copilot4万2026年10月17日 更新

Generate coding agent instruction files from a project's actual code using AgentRC. Capture detected languages, frameworks, and conventions in one shared file or split rules by topic and project area, with a preview before writing.

中文简介正在准备中。当前显示英语简介。

  • Create project instructions for VS Code Copilot
  • Refresh agent rules after project changes
  • Split monorepo instructions by project area
github/awesome-copilot4万2026年10月17日 更新

Customize AgentRC readiness assessments to match team or organization standards. Choose or create policies that adjust check importance, disable irrelevant checks, set pass thresholds, and define requirements for automated checks in CI workflows.

中文简介正在准备中。当前显示英语简介。

  • Set shared readiness standards across an organization
  • Focus assessments on AI tooling
  • Adjust the importance of individual checks
github/awesome-copilot4万2026年10月17日 更新

Analyze supplied ad performance data to identify wasted spend, strong campaigns, and next tests. Compare channels, assess whether test differences are meaningful, and produce budget reallocation recommendations with a prioritized action plan.

中文简介正在准备中。当前显示英语简介。

  • Identify ads and keywords to pause
  • Find campaigns and audiences worth scaling
  • Assess whether A/B test results are meaningful
github/awesome-copilot4万2026年10月17日 更新

Turn code files into learning resources by adding comments that explain syntax, programming concepts, and design choices. Adjust explanation depth and repetition to the reader’s knowledge while preserving file structure, encoding, and syntax.

中文简介正在准备中。当前显示英语简介。

  • Add beginner-friendly explanations to existing code
  • Document the reasoning behind syntax and design choices
  • Adjust comment depth for readers with different experience
github/awesome-copilot4万2026年10月17日 更新

查看 github 的全部技能

报告此技能的问题