New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Temporal Golang Pro

by sickn33 in sickn33/agentic-awesome-skills

A skill your agent uses when building durable distributed systems with Temporal Go SDK.

MITAuto-check passedBackend & APIs

Install Temporal Golang Pro

skills CLI
$ npx skills add sickn33/agentic-awesome-skills --skill temporal-golang-pro -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install sickn33/agentic-awesome-skills temporal-golang-pro --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/sickn33/agentic-awesome-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/temporal-golang-pro .claude/skills/temporal-golang-pro && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
temporal-golang-pro
GitHub stars
47k
Used in
2 other repos
Token cost
~2.3k tokens
SKILL.md length
637 words
Files
3
Skills in repo
1,497
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when building durable distributed systems with Temporal Go SDK.

  • Works in 4 steps: Gather Context: Proactively ask for → Verify Determinism: Before suggesting… → Implement Incrementally: Start with… → …
  • Building durable distributed systems with Temporal Go SDK
  • SKILL.md covers Overview, When to Use This Skill, Do not use this skill when and Step-by-Step Guide, plus 7 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Temporal Golang Pro is an agent skill from sickn33/agentic-awesome-skills. Use when building durable distributed systems with Temporal Go SDK. Covers deterministic workflow rules, mTLS worker configs, and advanced patterns.

Its SKILL.md is about 2.3k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files (for example `resources/implementation-playbook.md` and `resources/testing-strategies.md`).

It sits in Backend & APIs, covering Microservices. It works with Go. The repository describes itself as: AAS Core is the local, agent-first control plane for complete catalog discovery, agent-owned selection, stack validation, and planning, backed by 2,400+ agentic skills. Includes… The licence is MIT.

When your agent uses it

  • Building durable distributed systems with Temporal Go SDK
  • Tasks that involve Microservices

Example prompts

  • “/temporal-golang-pro”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Gather Context: Proactively ask for
  2. Verify Determinism: Before suggesting workflow code, verify against these 5 Rules
  3. Implement Incrementally: Start with shared Protobuf/Data classes, then Activities, then Workflows, and finally Workers.
  4. Leverage Resources: If the implementation requires advanced patterns (Sagas, Interceptors, Replay Testing), explicitly refer to the…

What it can do on your machine

Read from SKILL.md and the folder at commit 1c7bdea. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are go).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • pkg.go.dev
    • github.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Temporal Golang Pro loads about 2.3k tokens when it runs. Until then it costs about 42 tokens; SKILL.md has 637 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~42
When it runs · the whole SKILL.md, loaded when a task matches
~2.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from sickn33/agentic-awesome-skills at commit 1c7bdea, republished under its MIT licence (© sickn33). 637 words, ~2,326 tokens.

Download SKILL.mdSave it as .claude/skills/temporal-golang-pro/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
temporal-golang-pro
description
Use when building durable distributed systems with Temporal Go SDK. Covers deterministic workflow rules, mTLS worker configs, and advanced patterns.
risk
safe
source
self
date_added
2026-02-27

Temporal Go SDK (temporal-golang-pro)

Overview

Expert-level guide for building resilient, scalable, and deterministic distributed systems using the Temporal Go SDK. This skill transforms vague orchestration requirements into production-grade Go implementations, focusing on durable execution, strict determinism, and enterprise-scale worker configuration.

When to Use This Skill

  • Designing Distributed Systems: When building microservices that require durable state and reliable orchestration.
  • Implementing Complex Workflows: Using the Go SDK to handle long-running processes (days/months) or complex Saga patterns.
  • Optimizing Performance: When workers need fine-tuned concurrency, mTLS security, or custom interceptors.
  • Ensuring Reliability: Implementing idempotent activities, graceful error handling, and sophisticated retry policies.
  • Maintenance & Evolution: Versioning running workflows or performing zero-downtime worker updates.

Do not use this skill when

  • Using Temporal with other SDKs (Python, Java, TypeScript) - refer to their specific -pro skills.
  • The task is a simple request/response without durability or coordination needs.
  • High-level design without implementation (use workflow-orchestration-patterns).

Step-by-Step Guide

  1. Gather Context: Proactively ask for:
    • Target Temporal Cluster (Cloud vs. Self-hosted) and Namespace.
    • Task Queue names and expected throughput.
    • Security requirements (mTLS paths, authentication).
    • Failure modes and desired retry/timeout policies.
  2. Verify Determinism: Before suggesting workflow code, verify against these 5 Rules:
    • No native Go concurrency (goroutines).
    • No native time (time.Now, time.Sleep).
    • No non-deterministic map iteration (must sort keys).
    • No direct external I/O or network calls.
    • No non-deterministic random numbers.
  3. Implement Incrementally: Start with shared Protobuf/Data classes, then Activities, then Workflows, and finally Workers.
  4. Leverage Resources: If the implementation requires advanced patterns (Sagas, Interceptors, Replay Testing), explicitly refer to the implementation playbook and testing strategies.

Capabilities

Go SDK Implementation
  • Worker Management: Deep knowledge of worker.Options, including MaxConcurrentActivityTaskPollers, WorkerStopTimeout, and StickyScheduleToStartTimeout.
  • Interceptors: Implementing Client, Worker, and Workflow interceptors for cross-cutting concerns (logging, tracing, auth).
  • Custom Data Converters: Integrating Protobuf, encrypted payloads, or custom JSON marshaling.
Advanced Workflow Patterns
  • Durable Concurrency: Using workflow.Go, workflow.Channel, and workflow.Selector instead of native primitives.
  • Versioning: Implementing safe code evolution using workflow.GetVersion and workflow.GetReplaySafeLogger.
  • Large-scale Processing: Pattern for ContinueAsNew to manage history size limits (defaults: 50MB or 50K events).
  • Child Workflows: Managing lifecycle, cancellation, and parent-child signal propagation.
Testing & Observability
  • Testsuite Mastery: Using WorkflowTestSuite for unit and functional testing with deterministic time control.
  • Mocking: Sophisticated activity and child workflow mocking strategies.
  • Replay Testing: Validating code changes against production event histories.
  • Metrics: Configuring Prometheus/OpenTelemetry exporters for worker performance tracking.

Examples

Show full SKILL.md (255 more words)Show less
Example 1: Versioned Workflow (Deterministic)
go
// Note: imports omitted. Requires 'go.temporal.io/sdk/workflow', 'go.temporal.io/sdk/temporal', and 'time'.
func SubscriptionWorkflow(ctx workflow.Context, userID string) error {
    // 1. Versioning for logic evolution (v1 = DefaultVersion)
    v := workflow.GetVersion(ctx, "billing_logic", workflow.DefaultVersion, 2)

    for i := 0; i < 12; i++ {
        ao := workflow.ActivityOptions{
            StartToCloseTimeout: 5 * time.Minute,
            RetryPolicy: &temporal.RetryPolicy{MaximumAttempts: 3},
        }
        ctx = workflow.WithActivityOptions(ctx, ao)

        // 2. Activity Execution (Always handle errors)
        err := workflow.ExecuteActivity(ctx, ChargePaymentActivity, userID).Get(ctx, nil)
        if err != nil {
            workflow.GetLogger(ctx).Error("Payment failed", "Error", err)
            return err
        }

        // 3. Durable Sleep (Time-skipping safe)
        sleepDuration := 30 * 24 * time.Hour
        if v >= 2 {
            sleepDuration = 28 * 24 * time.Hour
        }

        if err := workflow.Sleep(ctx, sleepDuration); err != nil {
            return err
        }
    }
    return nil
}
Example 2: Full mTLS Worker Setup
go
func RunSecureWorker() error {
    // 1. Load Client Certificate and Key
    cert, err := tls.LoadX509KeyPair("client.pem", "client.key")
    if err != nil {
        return fmt.Errorf("failed to load client keys: %w", err)
    }

    // 2. Load CA Certificate for Server verification (Proper mTLS)
    caPem, err := os.ReadFile("ca.pem")
    if err != nil {
        return fmt.Errorf("failed to read CA cert: %w", err)
    }
    certPool := x509.NewCertPool()
    if !certPool.AppendCertsFromPEM(caPem) {
        return fmt.Errorf("failed to parse CA cert")
    }

    // 3. Dial Cluster with full TLS config
    c, err := client.Dial(client.Options{
        HostPort:  "temporal.example.com:7233",
        Namespace: "production",
        ConnectionOptions: client.ConnectionOptions{
            TLS: &tls.Config{
                Certificates: []tls.Certificate{cert},
                RootCAs:      certPool,
            },
        },
    })
    if err != nil {
        return fmt.Errorf("failed to dial temporal: %w", err)
    }
    defer c.Close()

    w := worker.New(c, "payment-queue", worker.Options{})
    w.RegisterWorkflow(SubscriptionWorkflow)

    if err := w.Run(worker.InterruptCh()); err != nil {
        return fmt.Errorf("worker run failed: %w", err)
    }
    return nil
}
Example 3: Selector & Signal Integration
go
func ApprovalWorkflow(ctx workflow.Context) (string, error) {
    var approved bool
    signalCh := workflow.GetSignalChannel(ctx, "approval-signal")

    // Use Selector to wait for multiple async events
    s := workflow.NewSelector(ctx)
    s.AddReceive(signalCh, func(c workflow.ReceiveChannel, _ bool) {
        c.Receive(ctx, &approved)
    })

    // Add 72-hour timeout timer
    s.AddReceive(workflow.NewTimer(ctx, 72*time.Hour).GetChannel(), func(c workflow.ReceiveChannel, _ bool) {
        approved = false
    })

    s.Select(ctx)

    if !approved {
        return "rejected", nil
    }
    return "approved", nil
}

Best Practices

  • ✅ Do: Always handle errors from ExecuteActivity and client.Dial.
  • ✅ Do: Use workflow.Go and workflow.Channel for concurrency.
  • ✅ Do: Sort map keys before iteration to maintain determinism.
  • ✅ Do: Use activity.RecordHeartbeat for activities lasting > 1 minute.
  • ✅ Do: Test logic compatibility using replayer.ReplayWorkflowHistoryFromJSON.
  • ❌ Don't: Swallow errors with _ or log.Fatal in production workers.
  • ❌ Don't: Perform direct Network/Disk I/O inside a Workflow function.
  • ❌ Don't: Rely on native time.Now() or rand.Int().
  • ❌ Don't: Apply this to simple cron jobs that don't require durability.

Troubleshooting

  • Panic: Determinism Mismatch: Usually caused by logic changes without workflow.GetVersion or non-deterministic code (e.g., native maps).
  • Error: History Size Exceeded: History limit reached (default 50K events). Ensure ContinueAsNew is implemented.
  • Worker Hang: Check WorkerStopTimeout and ensure all activities handle context cancellation.

Limitations

  • Does not cover Temporal Cloud UI navigation or TLS certificate provisioning workflows.
  • Does not cover Temporal Java, Python, or TypeScript SDKs; refer to their dedicated -pro skills.
  • Assumes Temporal Server v1.20+ and Go SDK v1.25+; older SDK versions may have different APIs.
  • Does not cover experimental Temporal features (e.g., Nexus, Multi-cluster Replication).
  • Does not address global namespace configuration or multi-region failover setup.
  • Does not cover Temporal Worker versioning via the worker-versioning feature flag (experimental).

Resources

  • grpc-golang - Internal transport protocol and Protobuf design.
  • golang-pro - General Go performance tuning and advanced syntax.
  • workflow-orchestration-patterns - Language-agnostic orchestration strategy.

© sickn33, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files in skills/temporal-golang-pro of sickn33/agentic-awesome-skills.

  • SKILL.md
  • resources/implementation-playbook.md
  • resources/testing-strategies.md

Open the folder on GitHubat commit 1c7bdea

Used in 2 other repositories

We found 11 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in sickn33/agentic-awesome-skills, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Temporal Golang Pro next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Temporal Golang Pro compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Temporal Golang Pro this skillsickn33/agentic-awesome-skills47k2 repos~2.3kAutomated safety check: PassMIT
Golang Proantoniopaya22/go-rest-template1723 repos~1.2kAutomated safety check: PassMIT
Temporal Developerlatitude-dev/latitude-llm4.7k—~1.5kAutomated safety check: PassMIT
Golang Webmajiayu000/spellbook287—~2.7kAutomated safety check: PassMIT
Golang Best Practiceskoolamusic/claudefiles130—~935Automated safety check: PassMIT
Golang ArchitectureHoangNguyen0403/agent-skills-standard572—~577Automated safety check: PassMIT

Similar skills

  • Golang Pro

    antoniopaya22/go-rest-template

    Implements concurrent Go patterns using goroutines and channels, designs and builds microservices with gRPC or REST, optimizes Go application performance with pprof, and enforces idiomatic Go with…

    172 GitHub starsUsed in 3 repos~1.2k tokens
    Backend & APIsAuto-check passed

  • Temporal Developer

    latitude-dev/latitude-llm

    This skill should be used when the user asks to "create a Temporal workflow", "write a Temporal activity", "debug stuck workflow", "fix non-determinism error", "Temporal Python", "Temporal…

    4.7k GitHub stars~1.5k tokensUpdated 2 days ago
    Backend & APIsAuto-check passed

  • Golang Web

    majiayu000/spellbook

    Modern Go Web application architecture guide. An agent skill from majiayu000/spellbook.

    287 GitHub stars~2.7k tokensUpdated 2 days ago
    Backend & APIsAuto-check passed

  • Golang Best Practices

    koolamusic/claudefiles

    A skill your agent uses when building Go applications requiring concurrent programming, microservices architecture, or high-performance systems.

    130 GitHub stars~935 tokensUpdated yesterday
    Backend & APIsAuto-check passed

  • Golang Architecture

    HoangNguyen0403/agent-skills-standard

    Structure Go code with package-first boundaries, cmd/ and internal/, and explicit dependency wiring.

    572 GitHub stars~577 tokensUpdated yesterday
    Backend & APIsAuto-check passed

  • Golang Pro

    davila7/claude-code-templates

    Master Go 1.21+ with modern patterns, advanced concurrency, performance optimization, and production-ready microservices.

    33k GitHub starsUsed in 8 repos~1.9k tokens
    DevelopmentAuto-check passed

More from sickn33/agentic-awesome-skills

All 1,497 skills in this repo

  • Liuguang Banlan UI

    sickn33/agentic-awesome-skills

    Implements an interface in one of two named color modes, iridescent white or colorful black, from a parameterized starter that reports measured color intensity.

    47k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed

  • User Thoughts Memory

    sickn33/agentic-awesome-skills

    Saves a user's project decisions, rules and preferences into a project-local mdbase so later sessions and other agents can recover the intent.

    47k GitHub starsUsed in 1 repo~2.5k tokens
    Auto-check passed

  • Using LWC Memory and Graphs

    sickn33/agentic-awesome-skills

    Keeps project decisions, research and verified results available across coding-agent sessions through LWC memory, a document Wiki graph and a CodeGraph code index.

    47k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed

  • Find Complementary Founders

    sickn33/agentic-awesome-skills

    Guides an agent through assessing its own owner for cofounder fit, publishing an approved profile, and ranking complementary profiles other agents published for their owners.

    47k GitHub starsUsed in 1 repo~4.8k tokens
    Auto-check passed

  • Whatsapp Cloud API

    sickn33/agentic-awesome-skills

    Integracao com WhatsApp Business Cloud API (Meta). An agent skill from sickn33/agentic-awesome-skills.

    47k GitHub starsUsed in 2 repos~4.5k tokens
    Auto-check passed

  • Cline Pilot

    sickn33/agentic-awesome-skills

    Acts as a proxy for the Cline CLI, dispatching coding tasks one at a time, monitoring runs by hard evidence, relaying decisions to you and learning per-project preferences.

    47k GitHub starsUsed in 1 repo~4.6k tokens
    Auto-check passed

Works with

Categories

Questions about Temporal Golang Pro

What does Temporal Golang Pro do?

A skill your agent uses when building durable distributed systems with Temporal Go SDK. Temporal Golang Pro is an agent skill from sickn33/agentic-awesome-skills. Use when building durable distributed systems with Temporal Go SDK.

When should I use Temporal Golang Pro?

Temporal Golang Pro fits situations like: building durable distributed systems with Temporal Go SDK; tasks that involve Microservices.

How do I install Temporal Golang Pro in Claude Code?

Run `npx skills add sickn33/agentic-awesome-skills --skill temporal-golang-pro -a claude-code`. Or copy the skill folder (skills/temporal-golang-pro in sickn33/agentic-awesome-skills) into .claude/skills/temporal-golang-pro in your project. Claude Code loads it when a task matches its description.

How do I install Temporal Golang Pro in Codex?

Run `npx skills add sickn33/agentic-awesome-skills --skill temporal-golang-pro -a codex`. Or copy the skill folder (skills/temporal-golang-pro in sickn33/agentic-awesome-skills) into .agents/skills/temporal-golang-pro in your project. Codex loads it when a task matches its description.

Can I use Temporal Golang Pro in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add sickn33/agentic-awesome-skills --skill temporal-golang-pro -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/temporal-golang-pro, .gemini/skills/temporal-golang-pro, .github/skills/temporal-golang-pro and .opencode/skills/temporal-golang-pro in your project.

What does Temporal Golang Pro need to run?

SKILL.md names no scripts, command-line tools or credentials: Temporal Golang Pro is instructions for the agent only.

Does Temporal Golang Pro access the network?

SKILL.md names 2 domains. As links in the text: pkg.go.dev and github.com. This is read from the text; nothing was executed.

Is Temporal Golang Pro safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Temporal Golang Pro use?

Temporal Golang Pro is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Temporal Golang Pro use?

About 2.3k tokens (SKILL.md is roughly 9.3k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Temporal Golang Pro?

Skills that share tags, products or a category with Temporal Golang Pro: Golang Pro (antoniopaya22/go-rest-template, 172 stars), Temporal Developer (latitude-dev/latitude-llm, 4.7k stars), Golang Web (majiayu000/spellbook, 287 stars) and Golang Best Practices (koolamusic/claudefiles, 130 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Temporal Golang Pro?

sickn33 (a GitHub user) maintains it in sickn33/agentic-awesome-skills, which has 47,443 GitHub stars. The repository holds 1,497 skills in this directory. The repository was last updated on October 10, 2026.

Source: sickn33/agentic-awesome-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.