@samber
Covers backend, DevOps, and security, known for Go Code Style, Go Performance, and Go Error Handling.
All Skills by @samber
golang-code-style
by @samber
Go code style guide, focusing on clarity rules requiring human judgment, working with linters to ensure code quality.
golang-error-handling
by @samber
Go reliability engineer persona: every error must be handled or passed with context; silent failures and duplicate logs are equally unacceptable.
golang-security
by @samber
Audit Go code for security vulnerabilities, discovering common issues like SQL injection, path traversal, insecure random numbers, and providing remediation suggestions.
golang-design-patterns
by @samber
Go architect persona, advocating simplicity and explicitness, applying design patterns only when solving actual problems, opposing premature abstraction.
golang-performance
by @samber
Go performance optimization engineer persona, emphasizing profiling before optimization, using ultrathink mode for deep bottleneck analysis.
golang-concurrency
by @samber
Automatically write concurrent-safe Go code, generating goroutines, channels, and worker pools, avoiding resource leaks and race conditions.
golang-context
by @samber
Standardize the use of Go context.Context to propagate cancellation signals, timeouts, and request-scoped values, avoiding Goroutine leaks and unreleased resources.
golang-naming
by @samber
Automatically check and fix Go code naming convention issues, ensuring compliance with Go community conventions and improving code readability.
golang-database
by @samber
Generate type-safe Go database code, using native SQL instead of ORM, automatically handling transactions and connection pool management.
golang-safety
by @samber
Prevent nil pointers, array out-of-bounds, integer overflows, and other runtime errors in Go code, automatically adding defensive checks.
golang-project-layout
by @samber
Design reasonable Go project layouts based on project scale, avoiding over-layering; keeping simple scripts flat, and complex services layered as needed.
golang-documentation
by @samber
Automatically generate Go code documentation and API descriptions, ensuring doc comments conform to Go specifications and include complete example code.
golang-modernize
by @samber
Automatically upgrade Go code to the latest language version, adopting modern idiomatic syntax and standard library features, improving code quality and maintainability.
golang-data-structures
by @samber
Recommend optimal Go data structures based on performance characteristics, considering memory layout, allocation costs, and access patterns, avoiding premature optimization.
golang-lint
by @samber
Continuously check code quality in the development process using golangci-lint's multi-linter combination, automatically discovering and fixing code style issues.
golang-troubleshooting
by @samber
Systematically troubleshoot Go application failures, locating root causes through logs, tracing, and performance analysis, avoiding guesswork and trial-and-error.
golang-observability
by @samber
Automatically integrate OpenTelemetry metrics, tracing, and structured logs for Go services, establishing observability at the code level for diagnosable production issues.
golang-dependency-management
by @samber
Evaluate Go project dependency requirements, prioritizing standard library over external packages, avoiding long-term maintenance costs and security risks from excessive dependencies.
golang-structs-interfaces
by @samber
Design small and elegant Go interfaces and structs, prioritizing composition over inheritance, improving code testability and readability.
golang-popular-libraries
by @samber
Recommend production-grade Go libraries and frameworks, avoiding reinventing the wheel, prioritizing standard library and mature open-source solutions.
golang-dependency-injection
by @samber
Design testable Go dependency injection solutions, avoiding over-engineering, choosing the simplest DI pattern to meet decoupling needs.
golang-benchmark
by @samber
Write Go benchmarks conforming to statistical specifications, scientifically evaluating the actual effects of code performance optimization through multiple runs and flame graph analysis.
golang-cli
by @samber
Build Go CLI tools conforming to Unix philosophy, supporting pipeline composition, script automation, and friendly error prompts.
golang-stretchr-testify
by @samber
Write readable Go test cases based on the testify framework, improving test code maintainability using assertions and mocks.
golang-continuous-integration
by @samber
Configure efficient and reliable CI pipelines for Go projects, automatically executing builds, tests, and deployments upon code commits, ensuring code quality and security.
golang-samber-lo
by @samber
Use samber/lo functional utility library to simplify Go collection operations, replacing manual loops with chained calls, reducing boilerplate code and improving readability.
golang-stay-updated
by @samber
Track official Go documentation, pkg.go.dev, and community resources, helping developers stay informed about the latest tools, tutorials, and technological trends.
golang-samber-do
by @samber
Use samber/do container to manage Go application dependencies at the composition root, improving code testability and maintainability through type-safe dependency injection.
golang-samber-slog
by @samber
Go structured logging architecture design, automatically configuring sampling, sensitive information anonymization, and routing distribution. Error logs sent to Sentry, info logs stored in Loki.
golang-samber-hot
by @samber
Go memory cache system design, selecting eviction algorithms based on access patterns, planning cache size based on working set data, with built-in expiration, load failure, and monitoring handling.
golang-samber-ro
by @samber
Go reactive stream processing, using declarative pipelines instead of manual goroutine and channel orchestration, handling asynchronous or infinite data streams.
golang-samber-mo
by @samber
Go functional programming safety enhancement, using monads to make impossible states unrepresentable, converting nil checks to type constraints, and error handling to composable pipelines.
golang-samber-oops
by @samber
Use samber/oops to convert Go errors into structured data with context, making error messages self-explanatory and simplifying online problem diagnosis.
golang-spf13-cobra
by @samber
This skill guides Go developers in building powerful, Unix-philosophy-aligned command-line interface (CLI) applications using the `spf13/cobra` library. It covers command tree structuring, execution hooks (e.g., `RunE`, `PersistentPreRunE`), argument validation, persistent vs. local flag management, shell completion generation, and documentation customization. For Go projects using or adopting `github.com/spf13/cobra`, this skill is a crucial resource for ensuring professional, consistent, and maintainable CLI design, significantly boosting development efficiency and user experience.
golang-swagger
by @samber
This skill generates and maintains OpenAPI/Swagger documentation for Go projects. By using annotations within Go code (e.g., @Summary, @Param, @Success, @Router) and the `swag init` command, it automates API documentation generation, supporting integrations with popular frameworks like Gin, Echo, and Fiber. It ensures API documentation stays synchronized with the codebase, reduces integration errors, and establishes Swagger UI as a reliable single source of truth for API consumers, significantly boosting development efficiency and API usability.
golang-graphql
by @samber
This skill focuses on designing, implementing, and optimizing Golang GraphQL APIs, covering library selection (gqlgen, graphql-go), Schema design, Resolver patterns, and N+1 problem prevention. It helps developers build high-performance, maintainable GraphQL services, ensuring efficient data access and clear architecture.
golang-google-wire
by @samber
This skill focuses on implementing compile-time dependency injection in Go using `google/wire`. It leverages code generation to avoid runtime reflection, catching dependency errors at compile time. Supporting various providers, bindings, and struct injection, it's ideal for building maintainable, testable, and architecturally sound Go applications, significantly boosting development efficiency and code quality.
golang-spf13-viper
by @samber
This skill provides a layered configuration management solution for Go applications using the spf13/viper library. It resolves configuration values through a fixed precedence (e.g., flag > env > file > default), supporting environment variable binding, file reading, struct unmarshaling, and hot reloading. Ideal for Go projects requiring flexible and robust configuration, ensuring values are loaded as expected, preventing common errors, and enhancing application maintainability and reliability.
golang-uber-fx
by @samber
This skill guides on using the `uber-go/fx` framework to build Go applications, integrating a reflection-based dependency injection container, lifecycle management, a module system, and a signal-aware run loop. It's ideal for long-running services requiring graceful startup, shutdown, and modular composition, enabling developers to efficiently manage service dependencies and lifecycles.
golang-uber-dig
by @samber
This skill leverages uber-go/dig to implement dependency injection in Golang, offering a reflection-based container with features like Provide/Invoke, parameter/result objects, named values, and value groups. It enables developers to construct clean, maintainable object graphs at application startup, simplifying component management and testing in complex systems. Ideal for Go projects requiring precise control over dependencies, optimized code structure, and enhanced testability.
golang-how-to
by @samber
This skill is a Go skills orchestrator that automatically loads the most relevant sub-skills for each task, such as loading golang-grpc, golang-testing, and golang-error-handling when building a gRPC service. It ensures developers never miss essential skills, improving Go development efficiency and code quality.
devrel-hiring
by @samber
Writes employer-side DevRel hiring artefacts end to end: a role scorecard and job posting, a structured interview loop with a question bank, a portfolio plus paid work sample evaluation, and a 30-60-90 ramp anchored on a friction log. It splits requirements by company type and funding driver, scores candidates against a six-signal rubric, and flags the field's two named posting failure patterns. Use it when hiring a developer advocate, community manager or developer educator and you need one reusable, defensible standard instead of a generic engineering or marketing template.
devrel-career
by @samber
A one-person developer relations career coach on the candidate side. This skill interviews the user one question at a time to pick a target role (developer advocate, community manager, developer educator, DX engineer) and a credible technology niche, audits the public portfolio that decides most DevRel hires against real hiring signals, and produces a zero-to-hireable artefact curriculum with dates. It covers the six-rung IC ladder, the interview formats DevRel loops use (talk round, content and coding take-homes, DevRel-opinion round), gatekeeper and pit-trap patterns in job postings, and offer evaluation that weighs the reporting line before pay. Use it to break into DevRel, prep an advocate interview, or choose a track.
developer-relations-kickoff
by @samber
This Skill is the routing entry point for developer-relations work: at every project start or new session it first detects the repository and existing artifacts, asks at most five to seven targeted questions, then routes the current task to the right DevRel sibling skill and writes or resumes a shared devrel-context.md. Use it for new DevRel projects, periodic program check-ins, devtools business strategy, employer branding, docs or open-source routing and measurement - it delivers a warm start, a short routing list and an ordered skill chain with no repeated interview.
devrel-strategy
by @samber
Designs a company's developer relations program from the top down and returns a one-to-two page DevRel charter. It pins the funding driver, the two goals the program may serve, the pillar mix for its stage, audience priority, build-vs-buy per bet, staffing sequence and a written refused list. Use it when deciding whether to start DevRel at all, why existing devrel work is busy but not landing, which pillar deserves the next investment, who to hire next, or how to justify the program to an executive.
oss-launch
by @samber
Plans and runs an open-source project launch end to end: name and license clearance, a readiness gate covering README, install path and SECURITY.md, positioning with a deliberately limiting one-liner, channel sequencing, the launch-day war room, GitHub Trending mechanics, and post-launch measurement. Use it when a repository is about to be released, announced or shown on Hacker News, when you want the first real users and stars for a new library, or when a launch fell flat and you need to know why. Covers both individual-developer and company adoption.
developer-community-launch
by @samber
Decides whether a developer community is the right instrument at all, and if so which venue class fits, when to open it and how to seed it from zero. It interviews for demand, venue vacuum and seed supply, then plans founding-member seeding and the first 90 days with explicit go/no-go and shutdown criteria. Use it when someone says "we should start a group chat" and nobody can justify the sustained weekly hours a community will cost.
devtools-pricing-strategy
by @samber
Designs the pricing and packaging architecture of a developer tool: it settles the value metric (seats, consumption, capacity, outcome or a hybrid), designs free-tier limits and the tier ladder up to enterprise gating, and bounds every price point with a margin floor plus the self-host and build-it ceilings. It also produces a staged plan to change prices without a backlash. Use it whenever you need to decide what to charge, where free ends and paid begins, or how to raise prices safely.
developer-education-strategy
by @samber
This Skill decides whether and how to invest in structured developer education - learning paths, a developer academy, hands-on labs, badges or a full certification program - and then designs its operating model, staffing, refresh cadence, measurement and kill rules. It is used when enterprise buyers ask about trained staff, SI partners implement the product wrong, onboarding stalls beyond docs, or someone asks "should we certify our users". It stays at the strategy and operating-model level and never writes the courses themselves.
oss-license-strategy
by @samber
This skill helps a maintainer or a company settle an open-source project's license and contribution policy as one decision: weighing permissive against weak, strong and network copyleft and source-available options, mapping dependency-driven compatibility constraints, choosing DCO versus CLA versus nothing, and covering dual licensing and open core. Use it whenever someone asks which license to pick, whether MIT, Apache-2.0, GPL or AGPL fits, whether a CLA is needed, or how to relicense an existing project. It explains obligations and trade-offs but never gives legal advice.
oss-distribution-strategy
by @samber
Designs an open-source project's ongoing distribution mix after the launch window - registry metadata, code-host discovery surfaces, curated lists, downstream packaging, extension marketplaces, release cadence, dependency-graph position and procurement trust signals - then ranks each channel against real maintainer capacity. Use it when a maintainer asks why adoption flattened after launch, which registries or awesome lists to target, how often to release for visibility, or how to spend scarce maintainer hours on distribution. Every recommendation is held to one test: a neglected channel keeps speaking against the project.
devrel-radar
by @samber
Builds a personalised, time-budgeted watch list of developer-relations sources - podcasts, newsletters, practice hubs, peer communities, conference calendars, ecosystem reports and practitioners worth following - plus a routine that keeps it verified and fresh. It interviews the user on role, owned pillars, weekly time budget, consumed mediums, ecosystem and event needs, then ranks candidates by cross-surface recurrence and institutional backing rather than likes and follower counts. Use it when a developer advocate, community manager or solo OSS maintainer feels out of the loop, is deciding which DevRel podcasts, newsletters or Slack communities deserve their time, or needs to know which conferences to attend or speak at.
developer-meetup-program
by @samber
Designs and runs a recurring developer meetup or user group as a durable program rather than a one-off evening: host model, format menu, cadence, a standing speaker pipeline, in-kind venue and food sponsors with their conduct limits, no-show planning, the attendee-to-co-organizer ladder, and a health scorecard. Use it when starting a local group, when attendance is dying, when speakers or a pizza sponsor cannot be found, or when the founder needs to hand the series over without it collapsing.
oss-sponsors-brand-strategy
by @samber
Builds a company's open-source sponsorship portfolio: it names the primary mandate (brand marketing vs. supply-chain security), selects which projects and maintainers to fund, chooses an allocation model, sets an amount per recipient, and defines honest return metrics. It is written for OSPOs, DevRel leads, engineering and security leaders deciding an annual open-source budget, and it keeps every figure labelled as published or self-set so finance reviewers accept the plan.
open-standards-strategy
by @samber
Decides what posture a company should take toward one named open standard or protocol - ignore it, consume it, certify conformance, extend it, contribute upstream, co-found a spec with peers, or drive its own as a de facto standard. It also fixes the venue (Git spec, foundation, consortium, IETF/W3C/OASIS, ISO), the patent-licensing mode, the conformance plan and the kill rule. Use it for protocol strategy, standards-body engagement, standards wars, donating a spec to a neutral foundation, or a competitor's rival spec.
open-source-company-strategy
by @samber
Decides what a company open-sources and what stays proprietary, names the strategic motive behind each side of the line, assigns who owns the call, and states the irreversible commitments the company will never walk back. It is meant for company-level open source strategy - when someone asks whether to open source something, where the open-core line sits, or which features stay paid - rather than a plan for a single project or a license text choice.
developer-docs-structure-audit
by @samber
Audits an existing developer documentation set page by page, classifying each page against the Diátaxis modes and flagging misplaced or mixed-mode pages, coverage gaps per product surface, and navigation drift against the file tree. It returns a CNCF TechDocs rubric score plus a prioritized remediation queue, so a team facing a sprawling, hard-to-navigate docs site can decide exactly which small moves to ship first instead of guessing from scattered complaints.
oss-governance
by @samber
Interviews an open-source project to uncover how decisions are really made today, then chooses and documents a governance model that returns the most per maintainer hour. It produces enforceable rules covering decision rights, maintainer roles and promotion, voting and consensus, conflict escalation, succession, trademark and asset control, and whether to join a foundation or fiscal host. Use it when a project faces a contested decision, is adding or removing maintainers, worries about bus factor or single-vendor control, or is preparing a foundation donation. It fits solo, company-backed and multi-vendor projects, and never gives legal advice.
oss-contributor-onboarding
by @samber
This Skill audits and repairs the whole path a stranger walks to their first merged pull request: the CONTRIBUTING file, the good-first-issue queue, a clone-to-passing-tests command that works on a cold machine, and the first-pull-request review and recognition loop. Findings are scored against a blocking-plus-weighted rubric grounded in published newcomer-barrier research, and every recommendation ships with a file path, a command output, or a counted number as evidence. Use it when a maintainer says nobody contributes, good first issues get no takers, or first-time contributors disappear after opening a single pull request.
developer-quickstart-guide
by @samber
Writes and audits developer quickstart pages that carry a reader from zero to one verified success - a minimal happy path, copy-paste commands, expected output at every step, fail branches, and a cold-run time budget. Use it for APIs, SDKs, CLIs and self-hosted tools when onboarding must convert evaluators fast, even if the complaint is only that setup feels too hard.
technical-video-script
by @samber
Writes or reviews a shooting-ready, two-column visual/narration beat sheet for a technical video or screencast, with a 30-second hook, code-on-screen pacing, chapters, a runtime budget, accessible narration and a cut list. It also storyboards 2-5 minute animated or motion-design explainers and produces a platform description with one CTA. Use it for demo or walkthrough videos, video tutorials, YouTube Shorts, TikTok or Reels scripts, and for turning a blog post, changelog or docs page into a video.
devrel-analytics
by @samber
Builds an executable tracking plan for developer-relations surfaces - docs, blog, repositories, package registries, community venues and off-web appearances - defining an event taxonomy, an identity spine across surfaces that share no identifier, link-tagging discipline, source-confidence labelling and funnel views. Use it when numbers disagree between tools, when GitHub counts will not reconcile with analytics, or when docs traffic must be joined to signups. Instrumentation layer only; KPI targets belong to devrel-metrics.
devrel-team-structure
by @samber
Designs the developer relations org: which function DevRel reports to and what that line starves, the shape it takes (centralized, split, embedded, hub-and-spoke), the coverage map across advocacy, community, docs and education, and the interlocks with product, docs, support and sales. Use it whenever someone asks where DevRel should sit, who it should report to, or how to structure or restructure a DevRel team - even if they only say the team feels wrong.
devrel-metrics
by @samber
Builds a usable DevRel measurement framework: five to eight metrics tiered from reach through engagement to product and business impact, each with a definition, source, baseline-derived target, owner, action and a written attribution rule, with vanity metrics cut. Use it when someone asks how to measure DevRel, which KPIs matter, how to prove DevRel value or ROI to an executive, or why the numbers look good but leadership stays unconvinced.
devrel-competitor-analysis
by @samber
This Skill reconstructs a competitor's developer relations motion from publicly observable artefacts - docs and quickstart quality, open-source repo health, community size and responsiveness, Q&A tag activity, content cadence, event presence and hiring signals - then benchmarks them against your own program on the same axes and returns a per-row gap plan with a close, ignore or counter verdict. Use it for next-quarter planning, budget or headcount cases, positioning arguments, or when the team keeps asking why a rival attracts more developers.
developer-ecosystem-strategy
by @samber
Decides whether, when and how far a developer product should open into a platform others build on, covering extension points, partner-built integrations, third-party apps and complement ecosystems, and naming the permanent obligations that follow. It delivers a commitment decision with obligations, a seeding plan and kill criteria, and diagnoses why nobody builds on the API or keeps asking for integrations. Use it with a founder or exec before committing to a platform bet.
tech-podcast-interview-prep
by @samber
Prepares a guest for someone else's technical podcast, YouTube interview, livestream or panel. This skill runs show reconnaissance, picks the angle, builds an ABT message spine backed by evidence and stories, drafts a self-contained opening answer, extracts clip-safe sound bites, calibrates depth for the audience, covers recording-day mechanics, and closes with a post-publication promotion plan. Use it before any booked appearance so on-air answers stay accurate, quotable and reusable long after the episode feed moves on.
tech-talk-outline
by @samber
Turns an accepted conference talk abstract into a rehearsable outline: the one-sentence takeaway, a narrative arc, a minute-by-minute time budget, demo placement, and a slide skeleton with cut checkpoints. It preserves the promise the reviewers accepted, ranks candidate arcs by belief moved per hour of preparation, and pre-marks what can be dropped when the talk runs long. Use it when a talk gets accepted and the real work begins, when a rehearsal keeps overrunning, or when you must decide where the demo belongs.
developer-live-demo-design
by @samber
Turns an intended live technical demo into a system that still lands when the network dies, a command errors or the laptop refuses to mirror. It triages risk, recommends the fidelity tier a demo should run at (live, local, pre-recorded), and defines independently enterable checkpoints, a one-command environment reset, offline mode, recorded fallback assets and rehearsed recovery lines, all shipped as a demo runbook with a pre-flight checklist and rehearsal log. Use it for conference talks, workshops, webinars, launch streams and sales demos that contain a live segment, or whenever someone asks whether to demo live or pre-record.
developer-tutorial
by @samber
This Skill writes or audits teaching tutorials for developer products: one new concept per step, checkpoints learners can verify and resume from, guidance that fades, troubleshooting hooks embedded along the way, and a demonstrable skill at the end. It fits build-along guides, hands-on articles, workshop or lab handouts, and course lessons, and is especially useful for teams whose tutorials nobody finishes.
oss-sponsors-fundraising
by @samber
Designs a maintainer-side open-source sponsorship program: a tier ladder with pricing for individual and corporate sponsors, rewards that stay deliverable as the sponsor count grows, funding-goal and sustainability framing, and the invoice-and-entity path a company needs before it can pay. Use it when a maintainer asks how to get sponsors or funding, sets up or fixes GitHub Sponsors, Open Collective or FUNDING.yml, writes sponsor tiers or a sponsorship page, or wants a company to fund maintenance work.
tech-employer-branding
by @samber
Designs an engineering employer-brand strategy for teams that must attract software engineers: it defines an honest engineering EVP, selects seniority-matched channels (engineering blog, OSS presence, referrals, conference talks, pay-transparency artifacts), audits the verification surfaces candidates actually check, and sets a measurement baseline. Use it when engineering employer brand, weak applicant flow, salary-band publication, or falling offer-acceptance comes up. It covers early-stage through big-company stages and junior through staff-level targeting, while staying strictly at strategy altitude.
developer-community-moderation
by @samber
This skill writes a developer community's code of conduct and the private moderation playbook behind it, covering scope, an enforcement ladder, reporting channels, an incident-response runbook, a moderator roster and platform controls. Use it when a community needs real rules, when a live harassment or spam report must be handled today, or when an existing policy turns out to be unenforceable. It covers both company-run and volunteer open-source communities, and the output is publishable as-is.
developer-case-study
by @samber
Turns a customer's real production deployment into a technical case study that engineers actually believe. It qualifies the story before any writing starts, reconstructs the timeline from tickets, issues, PRs and telemetry, runs a guided source interview, and builds an evidence ledger tying every number to the instrument that produced it. Naming, quote and security approval run in parallel with drafting, so the finished piece ships with before-and-after architecture, published limitations and vetted quotes. Use it whenever a customer case study, developer adoption story, reference customer, migration or production rollout needs to become published proof.
docs-seo
by @samber
Runs on-page and technical SEO for a documentation site: crawling from the sitemap to check indexability, canonicals and hreflang across versioned and translated pages, redirects, the generator's title and description templates, internal linking, and preview-branch leakage, then produces an owner-assigned fix list against an agreed pass threshold. It is built for the failure modes a generic SEO audit misses, such as duplicate per-release and per-locale URLs or thousands of thin auto-generated reference pages.
devrel-content-calendar
by @samber
Turns scattered ideas, fixed dates and limited reviewer time into a dated quarterly developer-relations content plan with named owners and reviewers. It locks the fixed anchors first (releases, launches, conference and CFP deadlines), then balances an evergreen-versus-launch-tied mix and sizes every slot against real writing and review capacity. Use it when planning what to publish next quarter, when the content plan keeps slipping, or when a small team needs a realistic shipping rhythm.
conference-cfp-submission
by @samber
Turns a rough talk idea into a submission-ready conference proposal for one specific event: track fit, title alternatives, an attendee-facing abstract, verb-first takeaways, the reviewer-only fields, a credibility package, and a self-review scored against the committee's own criteria. It also helps decide which conferences are worth targeting and plan a submission calendar across a CFP season. Useful for community-run and vendor-run events alike (KubeCon, PyCon, FOSDEM), and especially when past proposals keep getting rejected and nobody knows why.
tech-press-relations
by @samber
Runs press and light analyst relations for a developer-facing product: qualifies whether there is a real story, shapes the angle a technical reporter can actually write, builds a tiered reporter-to-beat media map with byline evidence and contact routes, drafts the pitch, handles embargo and exclusive decisions, and prepares the press page plus briefing pack. It also states honestly what coverage is worth - credibility with buyers, executives, candidates and analysts, not sign-ups. Use it before a funding round, a launch, or a licence change.
github-profile-optimization
by @samber
Audits and rebuilds a personal or organization GitHub profile as a developer-relations surface: the profile README, the six pinned items, bio and social fields, the organization profile repository, and the contribution signals visitors read as evidence. It helps before a launch, a talk or a job search, or when an org page looks empty while the team ships weekly, and it routes asks like more stars or ranking into a defensible audit instead.
developer-first-gtm
by @samber
Designs the go-to-market motion for a developer-facing product: bottom-up self-serve adoption, developer-influenced sales, top-down with developer proof, or ecosystem-mediated distribution, plus the self-serve entry, the developer-to-buyer handoff rule and the land-and-expand path. Use it whenever a founder, DevRel or growth owner asks how developer adoption turns into revenue, whether to go bottom-up or hire sales, when to contact a free user, why signups are high and paid accounts flat, or how landed teams expand across an enterprise.
developer-segmentation
by @samber
Turns a vague 'developer' audience into three to five named, sized and ranked segments. The Skill picks two cutting dimensions - one that changes what you build, one that changes how you reach them - assigns each segment a size range with a confidence tier, splits every segment into user, champion, approver and buyer roles, scores the segments, and names one primary, one secondary and one written anti-segment. Use it when deciding which developer audience to serve first, how large an ecosystem or persona really is, or why content reaches everyone and converts nobody.
developer-keyword-research
by @samber
Mines docs-site search logs, support tickets, issue trackers and first-party query data to surface the exact strings developers search for, then ranks them into an evidence-backed keyword map for a developer tool, API, SDK or docs site. Because volume tools push nearly every error string and version-specific long-tail query to the bottom, this Skill prioritizes observed demand and treats tool volume only as a tiebreaker, marking already-ranking pages as update targets and intent splits as defects. It returns a writable, sourced list and does not write the pages themselves.
developer-event-sponsorship
by @samber
Builds a developer-event sponsorship plan: which conferences, meetups and hackathons to fund, at which tier, what to run on site, and how to prove the spend worked. It reads each package line by line - since tier names mean nothing across events - and ranks the portfolio against the stated objective, budget and staffing ceiling. Use it when a DevRel lead, developer marketer or founder is splitting an event budget, negotiating a sponsorship package, or asking whether a booth is worth it.
developer-champions
by @samber
Designs an unpaid, perks-only developer champions or ambassador program end to end: readiness check, intake model, published selection criteria, behaviour-based obligations, an access-first perk ladder, fixed terms with renewal and alumni status, and a cohort scorecard. Use it when launching or repairing an ambassador program, deciding what perks champions get, defining term and exit rules, or recognising top community contributors without paying them. It keeps the roster honest by designing the exit before the launch, so the title stays meaningful and inactive members can be removed without drama.
developer-journey-map
by @samber
Maps the developer journey for one audience segment — discovery, trial, adoption, contribution, advocacy — as a stage-by-stage table where each stage carries an exit event, a named owner, cited friction evidence and one tracking signal, then names the single leak worth fixing next. Use it when you need a developer adoption funnel, want to know why developers try the product but never reach production, or must assign ownership of developer experience across docs, product, support and community.
devtools-business-model
by @samber
Chooses the business model for a developer tool — proprietary SaaS, open core, hosted open source, support and LTS subscription, dual licensing, source-available, consumption metering, marketplace take-rate, OEM licensing — and names the go-to-market each one forces. Through a short interview it locks the product surface, buyer, licence position and effort ceiling, then runs constraint, paid-boundary and reversibility tests. The output is a decision memo with one primary model, a free/paid line, a value metric, a leading indicator, risks with signals and revisit triggers — useful whenever adoption is high and revenue flat.
version-migration-guide
by @samber
Writes or audits the migration guide for a breaking change: what breaks ordered by blast radius, each entry with a detection signal and before/after code, plus a deprecation timeline, the codemod's coverage boundary, and verification by a cold upgrade of a real project. It fits libraries, SDKs, CLIs, frameworks, hosted APIs and schema runbooks, so developers can move from version N to N+1 with the least reading and no surprises.
readme-optimization
by @samber
Audits and rewrites a repository README so a first-time developer can tell what the project is, why it beats the alternative, and run the first command within a minute. This Skill verifies every claim and the documented install against the source, orders the page into a bail-fast funnel, and prunes badges that earn nothing.
coding-agent-docs-optimization
by @samber
Turns SDK, API, or protocol documentation into something a coding agent can integrate from unattended: crawler access, machine-readable entry points such as llms.txt, markdown endpoints, OpenAPI and JSON Schema files, self-contained copy-paste-safe pages, and a measured first-attempt agent success rate. Use it when docs must let an agent wire up an SDK with no human in the loop, when agents invent API calls that do not exist, or when you need a repeatable cold-run harness that keeps every release agent-readable.
engineering-blog-post
by @samber
This skill writes or edits engineering blog posts that a skeptical developer audience will believe: it picks the right post pattern, attaches verifiable evidence to every claim, publishes trade-offs and limitations, ships runnable snippets, and strips marketing voice. Use it for "how we built it" or "we rewrote it in X" stories, debugging write-ups, public postmortems, benchmark posts, and product posts that must not read as marketing - or to review, de-jargon and de-market an existing technical draft. It runs in draft or edit mode, interviews the author first, and never rewrites passages the author has not approved.
developer-troubleshooting-docs
by @samber
Turns support tickets, issue history and error telemetry into troubleshooting and error-reference pages that a developer lands on by pasting the error string. Each entry follows the OASIS DITA troubleshooting model - symptom, conditions, cause, fix and verification - and the skill also builds an error-code catalog from one source of truth and wires fixes back into the product's own error output, so the same failure stops being re-answered every week.
changelog-writing
by @samber
Turns raw commits, pull requests and tickets into release notes developers actually read — a scannable record of what shipped, what it means in practice, and what breaks. Use it for CHANGELOG.md, a git-host release body, a hosted what's-new page or app-store notes, even when the commit history is messy and follows no convention. It adds the editorial layer generators skip: what to keep, what it means for the reader, and what breaks.
developer-community-health
by @samber
Designs and runs a developer community health measurement framework covering activity, responsiveness, contributor-funnel and sentiment metrics, with honest instrumentation and baseline-derived thresholds. It interviews the team, then ranks a short metric set by the data actually available, the deadline and the effort ceiling, and delivers a report that ends in decisions rather than a dashboard nobody refreshes. Use it when someone asks whether a Discord, Slack or forum is dying, or needs a community dashboard, contributor funnel, KPI set or engagement report.
build-in-public
by @samber
This skill designs a sustainable build-in-public practice for an open-source project or developer tool: how far up the disclosure ladder to go (shipping log, decisions, failures, metrics, revenue), a cadence the maintainer can actually hold, the platform mix, and the boundaries that keep security, customer and roadmap detail off the public record. It interviews the maintainer one question at a time, ranks the real outcome (contributors, users, sponsors, credibility, funnel) and sizes every recommendation against an honest monthly effort ceiling, so the practice survives a bad month instead of stalling.
docs-code-sample-standards
by @samber
Defines the policy every code sample in developer documentation must satisfy and audits an existing sample corpus against it, returning a ranked fix queue. The skill treats samples as a tested artefact with an owner, covering sample anatomy, copy-paste and security safety, execution tiers, single-sourcing from tested code, and language parity, so it is used when examples no longer compile, snippets drift after an API change, or users report copy-paste failures.
webhook-platform-design
by @samber
Designs a provider-side outbound webhook platform end to end: event taxonomy and catalog, payload envelope and schema versioning, an HMAC signing scheme based on Standard Webhooks, at-least-once delivery with retry/backoff and dead-letter policy, subscription lifecycle states, and the developer-facing debugging surface with delivery logs, replay, and test-event triggering. Use it when a product must push events to customer endpoints reliably and integrators need a written delivery contract instead of ad-hoc retries, unsigned payloads, and invisible failures.
developer-platform-kickoff
by @samber
This skill is the entry point and router for a developer platform skill collection. It detects the project environment and shared context file, runs a capped set of structured questions about the session goal, then routes the task to exactly one sibling skill — or plainly says that none fits. It outputs a short-list and an ordered skill chain rather than the design itself, so every new platform project start, recurring review or ambiguous public-API question lands on the right surface without repeated clarification.
app-marketplace-monetization-model
by @samber
Designs the monetization machinery for the operator of a B2B SaaS app or connector marketplace: merchant-of-record posture (marketplace-billed vs developer-billed), billing rails and account configuration, the fee stack (revenue share collected at source, program fees, processing pass-through), the developer pricing menu, fee waivers and incentive tiers, payout cadence with hold windows, and the marketplace-facilitator/VAT tax layer. Use it when charging for apps, collecting rev-share, configuring paid-app billing or developer payouts, or assigning tax liability — it outputs a single implementable design the platform can publish to developers.
developer-platform-hiring
by @samber
Employer-side hiring skill for developer-platform roles, covering API Product Manager, Platform Engineer/Architect, and Partner/Integration Engineer. It first disambiguates whether "platform engineer" means internal developer platforms or external API platforms, then calibrates the scorecard, interview loop, sourcing plan, and compensation stance to the company's archetype (infra/API-first, bolt-on public API, enterprise partner ecosystem). It also flags a scope-collapse pattern and sources from API-design communities rather than internal-IDP audiences. Use it to write a posting, design a loop, or benchmark pay against the general engineering/PM ladder.
developer-platform-career
by @samber
This skill plans a developer-platform career from the candidate side: it first disambiguates "platform engineer" (which elsewhere overwhelmingly means internal developer platforms) and stays strictly on the external/public-API track, then separates the API Product Manager, Platform Engineer/Architect, and Partner/Integration Engineer paths. It covers the real partner-engineer ladder, the API-design-vs-system-design interview split, and RFC/design-doc portfolio signals, so users can pick a company archetype, build an entry plan from wherever they stand, and benchmark an offer against the right compensation band. Use it when prepping for a platform or API-PM interview or evaluating an offer.
app-marketplace-launch-marketing
by @samber
Designs the launch and ongoing co-marketing program for a B2B SaaS marketplace operator: sizing and gating the founding launch cohort, planning a keynote-anchored reveal with partner embargoes, governing featured placement and app-of-the-month spotlights, and splitting budget between marketplace-wide demand generation and rationed per-partner co-marketing such as MDF, paid catalogs and tier gates. It turns a vague "we should launch a marketplace" ambition into a program a partner-marketing team can execute and partners can read without crying favoritism.
developer-portal-design
by @samber
Designs an external developer portal as a product surface rather than a static documentation site: map business-evaluator and integrating-engineer audiences, propose the information-architecture skeleton, design the signup-to-first-call onboarding path against a time-to-first-call (TTFC) target, and place every self-service surface such as key dashboard, request logs, sandbox, usage metering, and docs entry points. It also covers portal search with an AI answer assistant, RBAC and multi-tenant hierarchy, plus the build-vs-buy platform decision and a maturity roadmap. Use it when a public API needs a console that converts and retains developers.
app-marketplace-listing-standards
by @samber
Writes the listing-content rulebook a B2B SaaS app marketplace operator enforces against every third-party submission: required fields with objective reject criteria, screenshot and video specs, description quality bars, category taxonomy design, localization posture, badge display rules, and staleness/delisting enforcement. Submitters can self-check before they submit and reviewers apply one consistent bar, which turns subjective disputes into clauses anyone can point at and cuts rework across the catalog.
partner-app-onboarding
by @samber
This skill designs the partner-developer onboarding journey on a B2B SaaS platform, covering the registration gate, dev-account and sandbox provisioning, education and certification posture, the support-channel ladder, and the funnel instrumentation that shows where partners stall. It interviews first, then names the journey stages and validates each gate and provisioning choice before moving on. Use it when planning developer-program entry, sandbox tenancy for partners, certification gating, or time-to-first-submitted-app.
integration-partnership-strategy
by @samber
Designs a coherent technology-partnership portfolio for a B2B SaaS vendor: it scores candidate partners on demand evidence instead of relationships, places each on a referral-to-OEM depth ladder with graduation gates, and sets joint-roadmap governance, certification renewals with budget, sourced-vs-influenced pipeline attribution, and where the partnerships function reports. Use it when building partner tiers, ISV alliance plans, certification programs, or partner-pipeline attribution models. Strategy layer only; not for ETL-platform listings.
app-marketplace-review
by @samber
Designs the operator-side review and approval process for third-party apps on a B2B SaaS marketplace. This skill scales the review pipeline to data sensitivity, defines permission and data-access audit checkpoints, blends automated pre-screening with human triage, sets objective re-review triggers on app updates, hardens the publish channel against supply-chain attacks, and specifies appeal paths plus a severity-tiered revocation policy. Use it whenever the team needs a staffable, falsifiable review design instead of a one-time checklist.
api-auth-key-management
by @samber
A design skill for the API-key surface a platform issues to its own API consumers: key format with prefix and checksum conventions, hashed (irretrievable) versus encrypted (retrievable) storage, zero-downtime rotation with dual-key overlap, least-privilege scoping, individual / org / service-account ownership tiers, self-service key dashboard behavior, and SOC 2 / PCI-DSS 4.0 lifecycle governance. It turns a leaked, lost, or orphaned key into a contained event instead of an incident, and gives auditors ready lifecycle evidence. Use it for provider-side key design, not for consuming another vendor's API or designing an OAuth authorization server.
api-reference-quality
by @samber
Audits a published API reference at the endpoint level against its spec surface: every operation, parameter, response code and error documented, request/response examples present, per-language snippets in parity, try-it affordances working. It then installs source-of-truth gates (spec-driven generation, OpenAPI lint, contract tests, snippet parity in CI) so reference drift is stopped structurally instead of patched by hand. Use it whenever API reference completeness, undocumented endpoints or error codes, stale or drifting docs, or docs CI gates come up. Endpoint-level reference only - not portal IA or onboarding.
mcp-server-offering
by @samber
This Skill designs a SaaS product's MCP server as a product surface that AI agents operate: sizing the build investment, curating a 5-15 workflow-tool surface instead of mirroring API endpoints, applying write-tool safety patterns (scoped credentials, read-only lockdown, human-in-the-loop approval, idempotency and spend caps), choosing remote hosting with OAuth 2.1, versioning the tool surface, publishing for registry discoverability, and measuring agent adoption. Use it before opening a product to coding assistants or enterprise agent fleets.
api-test-mode-design
by @samber
Designs the test/sandbox mode of a public API platform so external integrators can build and validate without touching real money, messages, or data. It covers isolation architecture (soft test-mode toggle vs hard separate-copy sandbox), test-key prefixing, magic test values, simulated objects and personas, on-demand test events, deterministic time manipulation, reset and seeding, sandbox quotas, abuse controls, and graduation to live. Use it for payment, communications, or data-aggregation platforms that need a trustworthy stateful sandbox rather than a stateless mock.
api-rate-limit-policy
by @samber
This Skill designs the rate-limit policy a public API publishes to its consumers: metering models for REST request counting versus GraphQL cost points, tier quotas and burst allowances as two separate numbers, multi-tenant fairness layers, rate-limit headers (legacy X-RateLimit-* versus IETF RateLimit fields), 429 and Retry-After behavior, enterprise and partner override paths, and change-notice rules. Use it whenever rate limits, quotas, throttling tiers, 429 responses, noisy neighbors, or limit-increase requests come up. It stays in the policy layer, so integrators can predict, observe, and adapt to throttling instead of discovering each ceiling by tripping it.
api-idempotency-retry
by @samber
Designs the idempotency-key contract and client retry guidance for a public API: key derivation and per-caller scoping, storage TTL and replay windows, atomic claim mechanisms such as DB unique constraints, SERIALIZABLE row locks and conditional writes, payload-mismatch rejection, in-flight duplicate handling, exponential backoff with jitter, retry budgets, timeout propagation and SDK retry defaults. Use it when integrators must retry writes safely and duplicate charges, orders or submissions must be collapsed server-side.
api-status-communication
by @samber
Designs how an API platform communicates status to external consumers: monitoring-driven status pages, incident lifecycle and component semantics, pull and push channels, update cadence and templates, public postmortems, plus public SLA/SLO and maintenance-window notices. It is useful when a team needs to earn and keep developer trust through transparent, predictable incident communication instead of a hand-flipped green light.
integration-error-observability
by @samber
Designs how a platform surfaces integration failures to the external developers and partners who built against it: per-integration request, event and webhook delivery logs with replay, correlation IDs that survive from response header to support ticket, error-rate aggregation per API key split by 4xx/5xx/429, cooldown-aware proactive partner notification against alert fatigue, and a provider-side fleet view of which integrations are breaking. Use it when integrators must self-diagnose breakage, when support tickets keep piling up, or when partners learn about outages from their own angry customers instead of from you.
etl-connector-strategy
by @samber
Plans whether, where, and how a SaaS vendor should appear as a source connector on third-party ETL/ELT platforms. It gates any build behind demand validation, picks platforms based on where customers' data stacks actually run, ranks build paths (platform-managed listing, vendor SDK connector, custom open-source tap) by who absorbs the maintenance tax, audits the product API for extraction readiness, scopes CDC honestly since API sources ship pseudo-CDC only, and closes with certification targets plus a funded maintenance plan. Use it whenever a catalog listing, source connector, data-pipeline integration, or CDC request comes up.
integration-listing-optimization
by @samber
A marketplace-growth skill for B2B SaaS vendors optimizing their own listing on third-party app marketplaces such as Salesforce AppExchange, HubSpot, Atlassian Marketplace, Shopify App Store, and Slack. It diagnoses the view-to-install funnel, places keywords in the title and tagline, reorders screenshots and demo video, picks the right category, builds policy-compliant review velocity and badge prioritization, and defends rank against listing decay - useful both before submission and long after launch.
connector-marketplace-strategy
by @samber
Decides whether and when a SaaS should build its own app/connector marketplace, or instead join existing marketplaces or buy embedded iPaaS, and designs the operating model: curation level, partner mix, governance rules, take-rate architecture, and seeding sequence. Use it for ecosystem readiness, marketplace revenue-share, curated vs open admission, and third-party app governance decisions, producing an executable decision document that a later reader can falsify.
sdk-portfolio-strategy
by @samber
Define a public API's language-SDK portfolio as one approved strategy document: which languages get official SDKs and in what order, generated versus handwritten builds, official and community support tiers with a promotion gate, deprecation and end-of-life policy, and decoupling SDK SemVer from API versioning and release cadence. Use it when planning client libraries, choosing an SDK generator, or sunsetting a client library, so portfolio choices stop being per-SDK improvisation.
oauth2-provider-design
by @samber
Design the OAuth2 authorization-server surface a B2B SaaS exposes to third-party apps: the OAuth 2.1 baseline (PKCE for every client, no implicit or password grants, exact redirect matching), token TTL and refresh-rotation policy, scope taxonomy and granularity, consent screens with partial and incremental grants, client-registration posture, and a tiered app-verification program. Use it so a compromised app or leaked token stays a contained event, and so the platform never faces a forced retrofit of its whole app ecosystem.
public-grpc-api-design
by @samber
Design a public gRPC surface for external developers: run the when-gRPC gate at the public edge, then settle proto package and versioning conventions, buf breaking-change gates plus their annotation blind spot, unary-by-default streaming posture, the google.rpc.Status error model, transcoding gateway architecture (Connect-RPC, grpc-gateway, Envoy), and external auth with TLS. It fits API edge governance and interface review work, and stays at the design layer rather than language-specific server implementation.
public-graphql-api-design
by @samber
Designs a public GraphQL API that unknown third-party developers can safely query: the GraphQL-or-not gate, naming/nullability/Node-ID conventions, Relay cursor-connection pagination, union-based error payloads, depth and complexity ceilings, the federation trust boundary, and a persisted-query allowlist policy. Use it when a schema must stay evolvable for external consumers while the platform stays up under abusive or unpredictable queries.
api-error-design
by @samber
Designs the error surface of a public API so integrators can self-serve fixes from the response alone: a machine-readable error-code taxonomy (flat, code/subcode, or Google-style domain/reason), an RFC 9457 problem-details envelope with extension members, actionable messages, retryability signaling, and per-endpoint error documentation with request-ID tracking. Use it when defining 4xx/5xx bodies, auditing messy production error responses, or retrofitting a consistent taxonomy across services — it turns vague failures into structured, branchable signals that cut support tickets.
public-api-design-review
by @samber
Audits a public REST API surface - shipped or still on paper - against a checklist-driven design review: resource and URI naming, HTTP method and status-code correctness, field-naming consistency, pagination, filtering and field-selection conventions, one consistent error envelope, and Hyrum's-Law backward-compatibility risk. Every finding is bucketed as Must-change or Improvement against a cited rule, and the skill can also design the standing review program around it. Use it before or after launch whenever REST API consistency, endpoint naming, or API design governance is in question.
sql-jdbc-access-design
by @samber
Designs customer-facing SQL access to a product's data — a JDBC/ODBC endpoint, warehouse share, or hosted query surface. It gates the architecture by scan frequency (zero-copy share, replicated copy, per-tenant compute isolation), enforces tenant isolation in the engine with secure views and row-level security, and publishes an additive-only schema-stability contract checked in CI. It also covers BI-tool driver certification, query governance and cost caps, short-lived credential issuance, and the pricing shape of a SQL add-on. Use it before the first customer connects, so isolation, stability, and unit economics are settled rather than discovered in production.
api-versioning-policy
by @samber
Writes a complete API versioning and deprecation policy: choosing the version-carrying scheme (URI path, header, date-based account-pinned, or deliberate no-versioning), defining what counts as a breaking change, setting deprecation notice windows by audience, communicating sunset via RFC 9745 Deprecation and RFC 8594 Sunset headers, deciding fall-forward versus hard cutoff at the sunset date, and standing up breaking-change governance. REST version-and-sunset and GraphQL continuous schema evolution are treated as separate policies.
bulk-data-sharing-design
by @samber
Designs bulk file and lake export as a B2B product surface: choosing between Parquet file-drops on object storage and native warehouse/lake sharing, then fixing the partitioning and schema-evolution contract across batches, delivery cadence (full dump, incremental, CDC, streaming), per-recipient credentials for shared buckets, egress cost allocation, and cross-border residency. Use it when planning bulk export, data dumps to S3, Snowflake shares, Delta Sharing, or export freshness SLAs.
copywriting-hooks
by @samber
This skill generates diverse and engaging copywriting hooks based on five core levers: opening a gap, breaking a prediction, dropping into a scene, promising a payoff, and borrowing weight. It helps users quickly craft compelling first sentences that entice readers to continue, significantly boosting content appeal and reader retention, while also setting a clear tone for the article.
dev-event-kickoff
by @samber
dev-event-kickoff is the entry point and router for a 71-skill event-organizing collection: it detects project context first (event-context.md, git history, file inventory), then asks at most five to seven multiple-choice questions to pin down stage, format, edition and funding, and routes the task to exactly one sibling skill — or says plainly that none fits. It also bootstraps or resumes the project's shared context so the next session starts warm instead of cold. Use it at every conference, meetup or hackathon kickoff and at every recurring check-in on the same project.
event-debrief
by @samber
Runs the organizing team's own internal retrospective on one finished edition of a technical event: a blameless frame, a reconstructed timeline, what went well split from what went poorly, what actually fired reconciled against the risk register, budget plan and run of show, plus team-health findings. It closes with dated lessons-learned entries, each carrying an owner and a due date, so the output plugs straight into the next edition's plan. Use it after a conference, meetup or hackathon to review an edition against the goals the team set and build a durable lessons-learned log.
event-budget
by @samber
Builds the budget and P&L for one edition of a technical event: every cost line split into fixed and per-head, revenue mix mapped against the funding model, a Good/Better/Best scope-tier ladder so break-even returns three answers instead of one, a contingency sized as a stacked floor/pad/downgrade ladder, and outflows scheduled against the dates sponsor and ticket money actually lands. Use it to model conference or hackathon costs, find break-even, size a reserve, plan event cash flow, or decide what to cut first when revenue falls short. It consumes real quotes and prices, never sets them.
event-ticket-pricing
by @samber
Designs the attendee ticket pricing ladder for a technical event: deciding free, nominal or commercial pricing against the funding model, splitting tiers by who pays (employer-funded, self-funded, student), subtracting comps from capacity, gating discounts on a date or ticket count, adding a need-gated scholarship rung, and writing the group, invoicing, refund and transfer policy before tickets go on sale. Use it when planning a community conference or meetup and you need defensible numbers, a fair payer split, and refund rules that still hold up after launch.
dev-event-career
by @samber
A candidate-side career coach for tech-event organizers, mapping the producer, manager, coordinator and community-manager shapes of the field. It states plainly that no universal title ladder exists, then gives the one real named ladder plus CMX's community-management competency model, the volunteer-to-paid entry path, interview prep (portfolio review, scenario questions, the five-competency loop, the paid mini-audit work sample), named practitioner quotes, and compensation across in-house, agency and non-profit contexts. Use it when you want to break into event organizing, prep for a producer or community-manager interview, or evaluate an offer.
dev-event-hiring
by @samber
Employer-side hiring skill for tech-event-organizing roles: it calibrates the scorecard to the operating context (in-house, agency, non-profit/community, or standing conference business), assembles an interview loop from the general event-planner sequence plus CMX's five-competency set and a paid mini-audit work sample, sources candidates from general event-industry boards, and anchors compensation to named sources such as PCMA, BLS and Glassdoor instead of one blended figure. Use it when you need to write a posting, design a hiring loop, or hire an event producer, manager or community manager.
event-talk-selection
by @samber
Runs the full review and selection process after a call for papers has already collected submissions: committee composition, how blind review executes and what it cannot fix, scoring rubrics, multi-round score-to-shortlist-to-program-fit cascades, conflict-of-interest recusal, diversity and first-time-speaker balancing, acceptance-rate management, and accept/decline/waitlist communication. Use it whenever a program committee, talk rating grid, blind CFP review, reviewer conflict of interest, or acceptance and rejection emails are involved - even if nobody says "selection". It turns a subjective, deadline-pressured debate into a documented, repeatable pipeline that honours what the published call promised.
event-media-partnerships
by @samber
Sets up barter media and community partnerships for a technical event - visibility-for-visibility deals with newsletters, podcasts, online communities and developer-ambassador programs, where no cash changes hands. It defines deal classes, partner types, exchange formats (calendar listing, logo-and-social swap, newsletter mention swap, podcast exchange, full media-partner tier), deal terms and delivery tracking for both sides. Use it to find media partners, build a community-sponsor tier, or trade newsletter mentions and podcast slots for event visibility.
event-comms-channels
by @samber
Designs the attendee-facing communication channel architecture for one edition of a technical event: which channels exist, who is on each, which class of message routes where, how several writers stay consistent, and how every channel is wound down after the event. It writes no copy — it hands the executing team a channel roster, routing rules and a dated shut-down plan, so room changes, schedule slips and on-site alerts reach the right place instead of drowning in chat.
event-landing-page
by @samber
Builds the public front door for a technical event and the small site around it: the page shape that matches the funding model, the section set, a date-gated CTA state machine that renders Propose only inside the CFP window and Register only inside the registration window, the accessibility target, and the event structured data. It is useful when a conference, meetup or hackathon site must go live on fixed dates and stay honest while tickets, speakers and the agenda do not exist yet, and when a pre-launch check is needed to confirm every button matches the campaign calendar.
event-growth-strategy
by @samber
A growth strategist for established technical events: it reads demand headroom and decides whether the next edition should be bigger, the same, or smaller, then picks exactly one lever - venue squeeze, added track or day, venue step-up, or price-led growth. It also gates venue moves on contract risk (deposits, attrition penalties, F&B minimums, long lead times) and treats deliberate non-growth (caps, lotteries, shrinking back down) as a legitimate strategy.
event-portfolio-strategy
by @samber
This skill shapes one organizing team's set of event properties - flagship conference, meetup series, hackathon, podcast or always-on online space - into a portfolio where each one feeds the others. It covers what each property is for, the funnel path between them, cadence collisions across one team and audience, how much brand, audience list, team and sponsors are shared, the allocation posture, and add/kill criteria written before they are needed. Use it when deciding whether to add a second event or format, how a meetup feeds a conference, how to keep momentum between editions, or which property to retire.
event-social-media
by @samber
Plans and runs a technical event's own social presence inside the channel weight, phases and dates already fixed by the marketing plan: platform selection, campaign versus community hashtags, posts mapped to each campaign phase (announcement, CFP, speaker reveal, final push, live), amplification asks to speakers and sponsors, and day-of coverage. Use it when a conference or hackathon needs a social content calendar, an event hashtag, or a volunteer briefed for live posting, without re-litigating channel weight or budget.
corporate-event-strategy
by @samber
Decides what a company-run technical event is funded to accomplish before anyone plans it: the goal mix (ecosystem goodwill, developer adoption, customer retention, sales pipeline, or a blend), which function owns the budget line and who co-funds it, and the measurement commitment written down before registration opens. Use it when a company asks why it runs a user conference, community day, developer summit or roadshow, which goal to optimise, who should pay, or how to prove it worked. Strategy layer only.
tech-podcast-youtube-channel
by @samber
Runs an organizer's own standing podcast or video channel as a cross-edition media property: whether to sustain it, the cadence commitment and its named owner in the quiet months, guest sourcing outward from the speaker pool, the two-way feed with the event cycle, and the wind-down or handover when organizers change. Use it when a team wants a show that keeps publishing between editions instead of restarting from zero each year.
event-official-social-program
by @samber
This Skill decides how many official social occasions a technical event runs and how they sit against each other - one occasion, a second on its own slot, or a themed multi-activity track. It also sets the inclusion floor that a whole slate must clear rather than checking each activity separately, so caregivers, non-drinkers and other groups are not quietly excluded. Use it when asked whether to run more than one social activity, whether two can share the same hours, how to publish a social track, or which activity a given attendee can join.
event-format-selection
by @samber
Decides a technical event's structure before anything is scheduled: the event shape (recurring meetup, hackathon, unconference, single-day or multi-day conference), single versus multi-track, workshop-day ratios, the session-format mix (curated talks, workshops, open space, ignite, fireside chats, panels), delivery mode (in-person, virtual, hybrid), and hackathon demo/judging structure. Use it when picking an event format, deciding single-track versus multi-track, weighing hybrid delivery, composing a session mix, or graduating a meetup into a conference. Structural decisions only - schedule grids and clash avoidance belong elsewhere.
event-date-selection
by @samber
This skill picks the date a technical event runs on - the decision every other plan hangs off. It settles weekday versus weekend from whose calendar the audience actually lives on (employer time versus personal time), tests seasonality and holiday assumptions against the user's own prior editions, scans competing and anchor events for conflict or deliberate piggybacking, and negotiates candidate windows against venue availability instead of fixing one date first. Use it when choosing a conference weekend, checking date clashes with other events, or deciding how far ahead to announce.
event-sponsor-pricing
by @samber
Builds the sponsorship rate card for a technical event: sellable inventory derived from the budget's revenue target, cost-recovery, market-comp and value-based price setting, a 2-4 tier ladder with anchoring and a sane top-to-floor ratio, add-on and exclusivity premiums, in-kind valuation, plus a discount and negotiation policy fixed before the first sponsor call. Use it for tier prices, package pricing, or choosing between a published ladder, quote-gated pricing and no ladder at all.
hackathon-brief-design
by @samber
This Skill writes the pre-event document every hackathon team reads: problem statements sized to the time box, thematic challenge tracks, published rules and eligibility text, the submission-artifact checklist, sponsor-challenge framing, and the names (never the weights) of evaluation categories. It gives organizers one authoritative, self-consistent brief so teams know what to build and what to hand in, and so disputes at the closing ceremony trace back to a written clause instead of a verbal promise.
virtual-event-production
by @samber
Runs the technical and audience-facing delivery of a fully-remote technical event once the virtual format is already settled: picking the platform that replaces the venue, testing remote-speaker connectivity with local backup recordings, staffing live chat and Q&A moderation, and rehearsing the failures a roomless event must survive. Use it for online conferences or meetups so a dropped stream, a speaker who cannot connect, or an unstaffed question channel never turns into an unplanned outage.
event-planning-timeline
by @samber
This skill builds the months-long work-back schedule for a technical event, starting from a fixed doors-open date. It splits the plan into parallel tracks such as venue, program and CFP, sponsors, marketing and ticketing, then works each one backward into milestones, cross-track dependency gates, and latest-safe commitment dates. It also sets an explicit buffer policy and replanning checkpoints that cut scope instead of moving the date. Use it when you need an event planning timeline, a conference retroplanning or reverse schedule, milestone sequencing, or when an event is running behind and needs a credible replan.
event-run-of-show
by @samber
This Skill writes and runs the day-of run of show for a technical event once the schedule is published: the minute-by-minute playbook staff execute from, day-of role assignment (MC, speaker introducers, room leads, the organizer on duty), cue sheets at every transition, an organizer-only comm channel kept separate from attendee-facing ones, the escalation path with live incident response, shift rotation with verified handoffs, and closeout. Use it whenever a day-of rundown, cue sheet, MC or room-lead role, organizer channel, shift handoff, or a live call about what to cut when a session overruns is on the table.
event-content-repurposing
by @samber
Turns one edition's already-captured material — recordings, slides, transcripts, photos — into derivative published artifacts: it decides which formats get made, on what cadence they drop, under which licence, and what each speaker is asked to amplify. Use it after a conference to plan clips, write-ups and transcripts, choose release timing, and gate third-party slide material or attendee photos before republication. It also hands up a content inventory the next edition's campaign can schedule.
frontend-design-deslop
by @samber
This skill helps users create distinctive, non-generic UI and application designs by adopting a strategy-first approach. It guides the process from defining project personality and positioning to establishing typography and color systems, then applying detailed craft layers like layout and components. This ensures unique, high-quality designs that avoid the common "AI-slop" aesthetic, making it ideal for any web frontend, app, or dashboard requiring a strong visual identity.
workshop-program-design
by @samber
This skill designs how a hands-on technical workshop or training session actually runs once the format decision has committed hours to it: facilitator coverage, participant prerequisites and environment setup, capacity ceilings, session length, materials, and what to do when a room full of laptops cannot reach the network. Use it when planning the sessions inside a workshop day, sizing helper coverage for a lab, writing prerequisites or setup instructions, capping seats, choosing bring-your-own-laptop versus a provisioned environment, or surviving bad venue WiFi.
hackathon-cash-prize
by @samber
Designs and lands a hackathon prize scheme: the medium (cash, hardware, product credits or no monetary prize), the total pool and where it sits in the event budget, the split across places and sponsor tracks, who is legally eligible to receive a payout, and how the handover happens. Use it whenever prize amounts, cash-versus-hardware trade-offs, splitting a pool across tracks, or eligibility for minors, sponsor employees and cross-border winners come up. This Skill names contest-law, tax and cross-border exposure categories and routes them to counsel or a fiscal host rather than inventing thresholds or form names.
event-hospitality
by @samber
This skill decides the shared hospitality floor for a technical event: the catering service style, what a scheduled break contains, the alcohol posture, and whether an evening or social programme exists, then outputs a brief others turn into orders, contracts and rotas. Use it early in conference planning to lock food, drink and social standards in one pass, so dietary counts are carried correctly and no sibling role has to re-decide the same fundamentals.
linkedin-ghostwriting
by @samber
This skill specializes in B2B LinkedIn ghostwriting, crafting high-conversion posts through strategic interviews, hook engineering, and refined body content. It assists users in writing posts for founders or executives, developing B2B social strategies, and providing effective copywriting frameworks to enhance brand influence and business conversion.
copywriting-tone-of-voice-creator
by @samber
This skill builds a comprehensive brand tone of voice guide (TONE.md) through discovery, voice definition, and channel modulation. It outputs detailed voice attributes, do's/don'ts, a tone modulation matrix, lexicon, and channel-specific rules. This structured guide ensures consistent, on-brand copy across various platforms, consumed by both human and AI content creators. It also adapts existing tone guides for new channels, helping brands maintain a unified voice in diverse contexts. Ideal for defining, refreshing, or porting brand voices.
event-sponsor-prospectus
by @samber
This skill assembles a technical event's sponsorship prospectus: it packages an existing value proposition and rate card into a credibility-before-price section anatomy, a checkmark tier table with real disclosed caps, named per-tier perks and add-on packages, an audience-demographics evidence section, and a web-page or PDF distribution format with a per-edition refresh routine. Use it for conference, meetup or hackathon sponsor decks and sponsor pages. It never prints guarantees, invented scarcity, or lead-list benefits the event cannot deliver.
cross-event-promotion
by @samber
This Skill sets up reciprocal promotion between independent technical events run by different organizers. It scores partner events, offers a menu of swap formats (community-calendar cross-listing, newsletter or social mention swaps, ticket-discount code swaps, speaker-pipeline sharing, conference-week co-location), provides the organizer-to-organizer ask, a lightweight swap agreement, and delivery measurement on both sides. Use it when arranging cross-promotion, a promo or ticket-code swap, co-location with a bigger conference, or speaker coordination across a circuit of independent events.
event-no-show-management
by @samber
Computes overbooking ratios, waitlist promotion triggers and day-of walk-in expectations for technical events, and hands catering an expected-show-up number instead of the registration count. It turns a room's hard capacity, cost-commitment deadlines and an already-run reminder sequence into a defensible registration ceiling, so free events stop wasting half their food and empty seats while paid, access-controlled or first-edition events are not silently overbooked. Use it whenever someone asks how many registrations to accept, whether to overbook, or how many people to order food for.
event-community-building
by @samber
Governs how one recurring technical event keeps its own audience warm during the months between editions. This skill sets the cadence posture for the gap with a named owner, builds a mechanism that converts attendees into returning participants and contributors, and produces a written handoff of the community asset so it survives an organizer leaving. Use it when asked what to post in the quiet months, whether a between-editions space should stay dormant, how to make attendees come back next year, or who takes over the community platform when an organizer departs.
event-press-relations
by @samber
Runs earned press coverage for a technical event - a one-way ask a journalist or creator chooses to grant, not a barter deal. It decides whether to pursue press at all (most community events correctly do not), sets a two-lane accreditation policy for editorial journalists and independent creators, builds an ungated media page, pegs announcements to CFP, lineup, programme, on-sale and wrap-up beats, holds an embargo posture, runs the on-site press room and interview logistics, and names a single spokesperson before an incident needs one. Use it whenever asked about press accreditation, press kits, media pages, pitching journalists, embargoed announcements, or who speaks to reporters.
event-marketing-plan
by @samber
Builds the complete attendee-acquisition plan for a technical event: audience segments mapped to channels, a campaign-calendar spine (a ticketed event's percent-of-ticket-sales ladder or a free event's percent-of-attendance-goal curve), campaign moments pinned to pricing and program dates fixed elsewhere, budget allocated across the channel mix, per-phase funnel targets, and each channel routed to the sibling skill that executes it. Use it whenever you need to plan how to fill an event, run a ticket-sales or registration campaign, choose promotion channels, split a promotion budget, or set registration targets by date. It turns scattered promotion ideas into one dated, budgeted and measurable plan.
event-attendee-email-sequences
by @samber
Designs and writes the full attendee email arc for a technical event: a dated send map from announcement to post-event follow-up, a sourced reminder cadence, and the finished copy for every send. It covers the know-before-you-go email, role and registration-state segmentation, consent and list hygiene, and a humanizer pass before anything sends. Use it whenever you must write an event announcement, registration confirmation, week-before or day-before reminder, or decide how many emails to send and when.
event-vip-social-program
by @samber
Designs the private gathering that runs alongside a public technical event by fixing only three decisions: how the seat list is assembled when sponsors, speakers and the organizer all nominate names, how invitations and the door work without ever publishing that a tier exists, and where the gathering sits against the public programme. It also draws hard boundaries against guest-qualification, hospitality and speaker-dinner skills so nobody re-decides the same thing. Use it when a sponsor asks for seats, when an invite-only room must stay unannounced, or when deciding whether a separate room is needed at all.
event-market-fit
by @samber
Reads whether a technical event's concept, audience and price combination genuinely meets demand - before launch (community baseline, CFP oversubscription, saturation mapping), mid-sale (checkpoint ladder and pace index against expected sales), and after an edition (attendee return, sponsor renewal, sellout-speed trend) - then composes the signals into a go, hold, pivot or stop call. Use this Skill to validate demand for a conference, hackathon or meetup-to-conference jump, judge whether ticket sales are on pace, decide whether an event should recur or scale, or diagnose why an edition underperformed. It reads signals only; launch scoping and growth levers belong to sibling skills.
event-positioning
by @samber
Define the strategic positioning of a technical event: what it stands for, which named alternatives it competes with, and which audience identity it serves. It covers the governance axis (community-run, foundation, media-run, vendor-owned), competitive-alternative mapping, best-fit attendee and sponsor segments, market-category strategy with its education tax, the positioning statement, contrast-not-attack anti-positioning, and the rebrand gate. Use it to position a conference, meetup or hackathon, differentiate it from neighbouring events, choose who it is for, weigh a vendor-neutrality claim, or judge a rename. Strategy only.
event-schedule-design
by @samber
Lays an event's already-selected talks into a publishable session grid: standardizing session lengths, matching talks to room capacity, detecting the four clash types including multi-speaker intersections, placing breaks and lunch, sizing buffers, positioning keynotes and plenaries as re-sync points, choosing synchronized versus staggered track starts, and checking speaker travel windows against every slot. Use it when building a conference agenda or multi-track layout, resolving speaker double-booking, or deciding when to publish the grid.
event-sponsor-fulfillment
by @samber
Turns a signed sponsorship agreement into delivered perks: this skill builds a tier-by-perk fulfillment matrix straight from the contract, gates every benefit behind full payment, chases sponsor assets against print and program deadlines, and plans the day-of sponsor experience including setup and teardown windows, shipping, booth staffing, power, WiFi and A/V. It also runs consented lead capture such as an opt-in raffle and delivers a post-event sponsor report within 72 hours, scored against the metrics each sponsor named, so the renewal ask rests on evidence rather than goodwill.
event-b2b-matchmaking
by @samber
Designs the structured 1:1 business meeting program for a technical event: whether to run one at all, how the two sides are matched (directory, brokering, mutual opt-in, scored ranking), how slots get booked inside the grid, what meeting count a sponsor package may honestly commit to, how no-shows are absorbed, and what to measure. It helps organizers keep sponsor promises deliverable and repeatable without turning a developer event into a trade-show floor.
event-speaker-cold-outreach
by @samber
This skill writes and sequences the cold invitation to a speaker the shortlist already picked - the message, not the search. It covers what a first invitation must disclose up front (event basics, honest budget and travel terms, the answer deadline, how you found them), personalization built from the shortlist's own \"why\", ranked first-touch channels, follow-up cadences that add a new angle instead of bumping, and the fee conversation where speakers have no rate card. Use it whenever you need to write a speaker invitation, pitch a keynote candidate, follow up on an unanswered invitation, or answer a speaker who asks for a fee.
event-cfp-design
by @samber
This skill designs the call for papers of a technical event: the open/close timeline worked back from the event and program-announcement dates, the submission form fields, which session formats the call offers, the anonymization posture (named, opt-in, or mandatory blind review), review criteria published in the call itself, stated speaker benefits, per-person submission caps, and first-time-speaker support. Use it whenever you need to open or write a CFP, set a CFP deadline, design a talk submission form, or decide on blind review.
event-first-edition
by @samber
Takes an organizer from "we decided to do this" to doors-open on edition 1 of a tech event: the smallest edition worth running, scope discipline against the full vision, the first cross-organization team, a decision-to-doors-open reverse timeline, and a pre-mortem of first-edition risks with written go/no-go dates. Use it when starting a new conference or hackathon, or forming a founding organizer team.
hybrid-event-design
by @samber
Designs the programme and the staffing for a technical event that serves an in-room and a remote audience at the same time, once hybrid has already been chosen: which sessions the remote audience gets, how far a remote attendee's voice reaches the stage, the cue track the stream needs beside the room's, and who staffs the remote side. Use it to keep online attendees from being treated as second-class participants and to stop remote Q&A, cues and coverage from being improvised on the day.
event-vip-management
by @samber
Designs the guest-specific layer for named attendees whose presence creates escort, protocol, security or discretion obligations — public officials, dignitaries, major funders, executives with no booth duty — without building a status tier the room can read. This Skill runs an obligation-based qualification test (never status), builds an identification roster, sets escort depth, and picks a visibility posture that meets the obligation invisibly. Use it whenever someone mentions receiving a minister, mayor, funder or visiting executive, VIP badges, reserved seating, escorting a dignitary, or coordinating with a guest's own security detail.
event-continuous-improvement
by @samber
Turns several editions of a recurring technical event's dated debrief logs into operational trends and deliberate, evidence-backed changes. It gates noise from signal, groups differently-worded findings into themes, counts recurrence across editions, and persists a learning log so institutional memory survives organizer turnover. Use it when asked what keeps going wrong every year, how to stop relearning the same lessons, or what several editions of evidence say to change next; it explicitly does not cover a single edition's retrospective.
event-learning-expedition-design
by @samber
Decides whether to take a technical audience into an organization the organizer does not control, and on what terms, by setting the host-dependency posture (host speaker hosted in-house, one host site host-led or to a negotiated agenda, or a multi-host circuit) and the access posture - what the host lets attendees see and repeat afterwards. Use it when designing a learning expedition, company tour, field trip, site-visit programme or executive immersion, where the host's own premises, operation and staff are the programme rather than a room rented and filled by the organizer.
event-team-structure
by @samber
Designs the standing organizing team behind a recurring technical event - the structure that persists between editions. It fixes legal-entity posture first (none, fiscal sponsor, own non-profit), then decision-rights shape, the role taxonomy, succession and bus-factor planning, burnout guardrails, and the volunteer-to-paid-staff hiring gate. Use it when an event needs to govern its organizing team, form an association or non-profit, split decision rights, rotate or replace organizers, address organizer burnout, or hire its first paid staff - so each edition compounds on the last instead of restarting.
hackathon-mentoring
by @samber
Designs the mentor programme for one hackathon edition: sizing expertise coverage against the challenge tracks and any sponsor API, recruiting mentors through community and sponsor channels, tagging them by expertise, defining the request mechanic a stuck team uses to reach a mentor, briefing mentors on the help-versus-build boundary, and rotating coverage by expertise across shifts. It helps organizers stop guessing mentor headcount and gives every blocked team a clear route to the right expert during the hacking window.
event-speaker-sourcing
by @samber
Finds and qualifies speakers for a technical event outside the open call for papers — the proactive invitation channel running alongside or instead of a CFP. It maps programme gaps worth filling by invitation, sources candidates through referrals, expert and speaker directories, prior-talk review and community scouting (including international and multi-language searches), then grades every name Hot/Warm/Cold/Skip on evidence and returns a ranked shortlist with the rationale attached to each person. Use it for keynotes, invited-speaker shortlists, or any programme a CFP did not fill.
event-volunteers
by @samber
This Skill sizes and organizes the volunteer workforce for one edition of a technical event by working bottom-up from the posts the schedule requires, instead of guessing from a volunteer-to-attendee ratio. It defines roles with real fit criteria, builds shift plans with arrival buffers, runs sign-up and confirmation, prepares briefings including a code-of-conduct escalation script, and keeps coverage via a named replacement protocol and recognition for those who showed up.
startup-pitch-contest
by @samber
Design and run a startup pitch contest or demo day inside a technical event: the pre-event application and selection funnel, the pitch format and its time cost, the rubric an investor judge actually scores, the conflict of interest of a judge who may invest in the company they just ranked, and a prize built from introductions and committed meetings rather than cash. Use it whenever a pitch competition, demo day, call for startups, investor jury briefing or winner prize comes up. It refuses to invent pitch length, slate size, judge count or prize amounts, and routes securities and contest-law questions to counsel.
event-side-event-coordination
by @samber
Reviews and coordinates third-party satellite events that run around a main technical event: the vetting gate, calendar deconfliction against the published grid, name and logo usage rules, and the disclaimer defining what the main event does not vouch for. Use it whenever a user group, sponsor or attendee wants to run a party, meetup, dinner or workshop during the event dates, so the rules get decided deliberately once instead of at T-2 weeks, with trademark and liability exposure routed to counsel.
event-sponsor-agreement
by @samber
Turns an already-sold event sponsorship into a lawyer-reviewable term sheet - a structured clause checklist, never a signable contract or legal advice. It covers the deliverables schedule mirroring the sold tier, payment and late-fee terms, sponsor-withdrawal refunds plus the narrower organizer-cancels remedy, a force-majeure remedy, category exclusivity bounded by published caps, liability and insurance, a code-of-conduct clause with an ejection right, mutual logo licensing, and term and renewal. Use it whenever a sponsorship agreement, payment or cancellation terms, exclusivity, or a force-majeure clause comes up, even if the word "agreement" is never said.
event-code-of-conduct
by @samber
This Skill writes a technical event's code of conduct and builds the enforcement pipeline behind it: who and which spaces the policy binds, reporting channels including an anonymous path, response-team composition and rehearsal, the on-site incident runbook and its response clock, the sanctions ladder with appeals, and the transparency report. Use it to draft or review a conference or meetup code of conduct, set up incident reporting, train a CoC response team, decide a sanction for an attendee, or handle an on-site incident. Not legal advice.
copywriting-cta
by @samber
This skill specializes in designing end-of-article Calls-to-Action (CTAs). It generates customized copy, visual design, A/B testing plans, and accessibility checks based on the objective, audience, and content context. This skill helps users convert article readers into subscribers, leads, or community members, significantly boosting conversion rates and user engagement.
business-event-formats
by @samber
Selects which company-run event shape a company should run this year — invite-only dinner, executive summit, single-city user conference, multi-city roadshow, or a floor-primary trade-show event — and settles how its program is sourced and what shape its floor takes. Use it whenever a company weighs a user conference against a roadshow or a summit, asks what kind of event to put on for developers, customers or partners, or asks whether to run its own floor or exhibit on someone else's, even if they only say "we want to do an event". It stops at naming the shape and hands track count, floor operations, goals and budget to sibling skills.
event-cultural-identity
by @samber
This Skill designs and audits the lived culture of a technical event: it fixes the register (hacker, corporate, design, business) and expresses it consistently across venue, catering, swag, dress code, stage production, MC tone, and opening and closing ceremonies. Use it to define an event's vibe, invent a signature ritual, script an opening or closing, brief MCs and organizer-hosts, choose a swag posture, or audit an event whose stated values and on-site experience contradict each other.
event-booth-experience
by @samber
This skill designs a technical event's expo floor once per edition: the hall layout and traffic pattern that carries attendees past every booth, a tier-to-physical-spec catalog turning "floor presence, Gold" into table size, power, height and signage rules, the master setup and teardown schedule, per-booth power and WiFi distribution, staffing and conduct rules, and a floor-wide traffic mechanic such as a passport card. Use it when you need to lay out an expo hall or sponsor area, define what a sponsor tier's booth physically includes, schedule sponsor load-in and load-out, or pull attendees past low-traffic booths.
event-production
by @samber
Engineers the technical AV production of a technical event once format and session grid are fixed: capture tiers from a single smartphone to multi-camera vision mixing, signal-path architecture that separates room display from recorded output and crew monitor, redundancy against named recorded-audio failure modes, AV crew roles, and the written technical spec handed to venue sourcing and suppliers, plus the Media budget line and publication pipeline. Use it whenever a conference needs cameras, microphones, recording, livestreaming, an AV supplier brief, or a backup plan for technical failure.
event-vendor-sourcing
by @samber
Sources, vets and contracts the suppliers a venue does not include: caterers, AV and production, security firms, insurance brokers, swag and print. It first checks venue exclusivity, briefs every supplier in a category with one identical document, compares quotes line by line, and flags contract red flags and certificate-of-insurance asks — while refusing to invent supplier prices. Use it when planning a technical event, hackathon or conference and you need defensible supplier choices and contracts that survive event day.
event-speaker-experience
by @samber
This skill runs the full speaker-side experience from the moment a speaker confirms through to the post-talk thank-you: it collects bio, headshot, A/V needs and travel details against a deadline ladder, assigns one named point of contact, covers the pre-event briefing, slide deadline, tech check and green room, and documents recording consent with its per-format opt-out asymmetry. Use it whenever a community-run or vendor conference needs speakers to arrive knowing what happens when, and to be followed up after the event.
event-feedback
by @samber
Designs and runs participant-feedback collection for a single edition of a technical event: what gets asked, who answers, through which channel, when it goes out, and what flows back to respondents. It ships format-adapted question sets for meetups, conferences and hackathons, segments attendees, speakers and sponsors, and picks in-room versus emailed collection against real response-rate evidence. Use it when drafting a post-event survey, fixing a response rate nobody answered, or deciding what to do with the answers.
event-venue-sourcing
by @samber
This Skill sources and negotiates the venue for a technical event. It turns an attendance estimate and an already-chosen format into a written space program (main room, breakouts, hallway track, power and WiFi density, load-in), works a sourcing ladder that treats free campus, civic and company-hosted space as a real first rung, runs site visits at the depth the risk warrants, carries several venues against several dates, and flags the contract traps - attrition, food-and-beverage minimum, cancellation curve, insurance requirement - so the organizer signs terms they can actually live with.
hackathon-team-formation
by @samber
Decides how hackathon participants end up on teams: the published team-size rule and whether solo entry is allowed, the matchmaking mechanic that runs on the day, the protocol for anyone still unteamed afterwards, when membership freezes relative to the opening, and track-conditioned composition rules. A nine-question interview turns vague team-building intentions into publishable, executable clauses, so the rules text, the schedule slot and the prize roster all agree with each other. Use it when planning or reviewing a hackathon's team formation, not for matching a stuck team to expert help.
event-accessibility-inclusion
by @samber
This skill decides which accessibility and inclusion provisions a technical event commits to and at what depth: physical, sensory, dietary, economic and digital access, sizing, funding source, the public accessibility declaration, and the data-handling posture for accommodation requests. Use it when choosing whether to caption talks, run a quiet room, fund childcare or travel grants, draft an accessibility page, or answer an accommodation request — even if nobody says "accessibility". It decides the bar rather than delivering it, so organizers end up with a defensible, budgeted commitment instead of an ad hoc list.
event-attendee-experience
by @samber
Designs the general-attendee on-site journey for a technical event: check-in desk and badge pickup, badge privacy and scanning posture, signage and wayfinding, quiet room and facilities, meal and dietary mechanics, the help path, first-timer orientation, and a walkthrough audit of the finished design. This Skill turns an already-signed floor plan, schedule grid, register and accessibility bar into instructions a crew can execute, so attendees get in, find rooms, eat and ask for help without friction.
event-sponsor-outreach
by @samber
Runs the complete sponsor sales motion for a technical event: building and scoring the target list, timing outreach against sponsor fiscal-year budget lock-in, choosing the first-touch channel (warm intro, referral ask, cold email), running the exploratory call, capped follow-up cadences, objection handling, pipeline tracking, and treating renewal and net-new as two distinct motions. Use it whenever sponsors must be found, pitched, or renewed.
technical-article-writer
by @samber
This skill specializes in writing compelling technical articles and blog posts for developer audiences. It covers the full content pipeline, from idea sharpening and hook generation to structuring, drafting, and editing. By integrating technical writing frameworks and copywriting principles, it ensures high-quality, engaging content that resonates with developers, helping users efficiently produce impactful technical content.
humaniseur-fr
by @samber
This skill identifies and removes AI-writing patterns from French text, injecting unique voice, personality, and soul. It assists users in editing, reviewing, rewriting, or cleaning up French content that reads like ChatGPT/Claude output, making it sound more natural and human, thereby enhancing content quality and reader engagement.
conventional-git
by @samber
This skill enforces Conventional Commits v1.0.0 standards for Git branch naming, worktree naming, and commit messages. It ensures a clear and consistent Git history, enabling automated changelog generation, SemVer-driven releases, and improved team collaboration and code traceability. Use this skill when creating branches, writing commit messages, reviewing conventions, or setting up automation for your projects. It helps maintain parseable commit history and streamline development workflows.
copywriting-prose-creator
by @samber
This skill codifies the unique writing mechanics of a brand or individual, encompassing lexicon, syntax, rhythm, and structure, into a PROSE.md guide. It ensures consistent prose across multiple writers—human, ghostwriter, or AI—and various channels, independent of emotional tone. Ideal for establishing content factory rules, unifying ghostwriting voices, or building comprehensive house style guides.
site-launch-checklist
by @samber
This skill provides a comprehensive pre-launch audit and setup workflow to ensure new websites meet all requirements before going live. It orchestrates analytics setup, legal compliance, security headers, SEO optimization, copywriting consistency, OpenGraph settings, and quality gates (like Lighthouse, Core Web Vitals, and WCAG accessibility), assisting users in launching high-quality websites smoothly.
press-release-writer
by @samber
This skill writes professional press releases for any occasion, media type, and country. It assists users in drafting, writing, or improving press releases, media announcements, or PR statements, ensuring content meets journalistic standards, avoids marketing fluff, and is optimized for target audiences and regions, significantly boosting the efficiency and media impact of press release distribution.
influence-and-negotiation
by @samber
This skill provides a comprehensive influence and negotiation toolkit for any interaction requiring another person's agreement, including B2B sales, salary reviews, team collaboration, and customer communications. It helps users systematically plan strategies, effectively handle objections, and achieve consensus to optimize outcomes, whether preparing, engaging in live conversations, or drafting diplomatic messages.
promql-cli
by @samber
This skill provides a command-line interface for querying Prometheus and compatible engines, supporting instant queries, range queries, and metric discovery. It helps users quickly diagnose system performance issues, analyze time series data, and effectively troubleshoot observability challenges like latency, error rates, and saturation, thereby improving debugging efficiency.
substack-ghostwriting
by @samber
This skill helps users write, optimize, and grow content for Substack, including newsletters and web posts. It supports ghostwriting with voice matching, Substack algorithm optimization, Notes strategy, email formatting, SEO, growth tactics, and monetization planning. This enables creators to effectively expand their audience and generate revenue on the platform.
crxjs
by @samber
CRXJS is a powerful Vite plugin designed for modern Chrome extension development. It provides true Hot Module Replacement (HMR) across all key components, including popups, options pages, content scripts, and side panels. By intelligently reading your manifest, this skill automates the extension output generation, drastically simplifying the build process and accelerating development cycles for a smoother, more efficient workflow.
skill-progressive-disclosure-design
by @samber
This skill guides developers on how to apply progressive disclosure principles to logically split AI skill content (e.g., SKILL.md and reference files). It optimizes context window utilization and ensures reliable skill triggering, helping developers build more efficient and maintainable AI skills, preventing performance degradation and increased costs due to lengthy content.
training-report
by @samber
This skill automatically generates professional training or workshop reports, outputting them as a Markdown draft and a final .docx file. It gathers information through structured interviews, meticulously documenting the training process, participant feedback, and recommendations. This significantly streamlines the documentation of training outcomes, ensuring reports are professional and consistent.
snyk-agent-scan-compliance
by @samber
This skill acts as a compliance expert for snyk-agent-scan, remediating security alerts by restructuring content without suppressing information. It covers all files within a skill directory, ensuring content adheres to security standards and effectively prevents risks such as third-party content exposure, malicious external URLs, and prompt injection, thereby enhancing the skill's safety and reliability.