본문으로 건너뛰기
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(원문)

설치하기 전에 에이전트에게 전달되는 지시 내용을 확인할 수 있습니다.

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 / 1,000자

이 양식은 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의 스킬 모두 보기

이 스킬의 문제 신고