Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Get Started Free →

Go Patterns Skill · notque | DecimalAI

notque/go-patterns

NewSkillScoreMaintained

Go development patterns: testing, concurrency, errors, review, and conventions.

codingby notque

Links this skill to your agents and keeps it current with the author’s updates.

Automatic

Coding pack

1 · One-time — install the CLI (docs ↗)

pip install decimalai

2 · Get the skill — writes .claude/skills/notque-go-patterns/SKILL.md

decimalai skills pull notque-go-patterns --out .claude/skills/

No CLI? Get the same file — curl · raw file

curl -fsSL --create-dirs -o .claude/skills/notque-go-patterns/SKILL.md https://app.decimal.ai/s/notque-go-patterns/SKILL.md

Raw file: /s/notque-go-patterns/SKILL.md ↗ · machine-readable summary at /s/notque-go-patterns.json ↗

In productionGlobal

how this skill behaves on real traffic · last 30 days

No production data for this skill yet — usage numbers appear here once agents start running it.

Anonymized aggregate across every org using this skill — proof from real production use, not a demo.

Does this skill help? · Benchmark: with vs. withoutsign in to run this on your agents

22 test cases from the publisher’s eval.yaml · each run twice on gemini-3.6-flash — with the skill injected, then without · last run 2h ago

—+78% tokens0% turns55% of whole cases pass with skill (12/22)

Test case	Without → With	Effect	Δ tokens	Δ turns
case-04	✗→✓	▲ Improved	69%	0%
case-05	✗→✓	▲ Improved	162%	0%
case-02	✓→✗	▼ Worse	-19%	0%
case-10	✓→✗	▼ Worse	23%	0%
case-11	✓→✗	▼ Worse	-18%	0%

Showing 5 of 22 cases

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v5 — 8/17/2026

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

notque / vexjoy-agent

skills/engineering/go-patterns/SKILL.md

View on GitHub ↗

License MITImported 8/17/2026Version v2Bundled 20 files · scripts

Skill contents

scripts/

references/

SKILL.md

Go Patterns Skill

Umbrella skill for Go development: Google style, testing, concurrency, error handling, failure modes, code review, SAP CC conventions, and quality gates. Every Go task starts with the complete Google Go style baseline, then loads task-specific references.

Mandatory Google Style Baseline (Every Go Task)

Before reading, writing, changing, generating, debugging, or reviewing Go code:

Read ${CLAUDE_SKILL_DIR}/references/google-style-guide/LOAD_ORDER.md.
Read every file it lists, in order. Do not omit or sample parts.

Do not skip this baseline for small changes, tight context budgets, reviews, tests, or generated code. The ordered files reconstruct all four complete pinned upstream documents—overview, guide, decisions, and best practices—without excerpts. Apply their guidance to all Go code produced by the agent.

Use this precedence when guidance differs:

The target repository's explicit rules and required compatibility constraints.
The Google Go Style Guide's canonical rules.
Google Go Style Decisions' normative guidance.
Google Go Style Best Practices' non-canonical recommendations.
Task-specific references below.

Prefer local consistency only where the Google guide allows judgment. Do not create unrelated churn merely to restyle existing code. For new and nearby changed code, follow the current pinned guidance. Record a conscious exception when repository rules, generated-code constraints, or compatibility requirements require one.

Reference Loading Table

| Signal | Load These Files | Why | |---|---|---| | Every Go task | google-style-guide/LOAD_ORDER.md, then every file it lists | Complete Google style baseline; always load every part of all four upstream documents | | Testing | testing.md | Writing, fixing, or reviewing Go tests | | Concurrency | concurrency.md | Goroutines, channels, sync primitives, race conditions | | Error handling | error-handling.md | Error wrapping, sentinels, custom types, errors.Is/As | | Review patterns | preferred-patterns.md | Detecting code smells, over-engineering, bad Go patterns | | Code review | code-review.md | Reviewing Go code or PRs for quality | | SAP CC conventions | sapcc-conventions.md | Working in sapcc/ repos with go-bits | | Quality gate | quality-gate.md | Running make check, linting, pre-commit validation |

Instructions

Step 1: Load the Google Style Baseline

Read the load-order manifest and every file it names. This gate is complete only after every part of all four upstream documents has been read in the current task.

Step 2: Identify the Go Domain

Classify the task into one or more domains, then load the corresponding reference files. Only load what is needed -- do not load all references for every task.

| Domain | Load Reference | When | |--------|---------------|------| | Testing | references/testing.md | Writing, fixing, or reviewing Go tests | | Concurrency | references/concurrency.md | Goroutines, channels, sync primitives, race conditions | | Error handling | references/error-handling.md | Error wrapping, sentinels, custom types, errors.Is/As | | Review patterns | references/preferred-patterns.md | Detecting code smells, over-engineering, bad Go patterns | | Code review | references/code-review.md | Reviewing Go code or PRs for quality | | SAP CC conventions | references/sapcc-conventions.md | Working in sapcc/ repos with go-bits | | Quality gate | references/quality-gate.md | Running make check, linting, pre-commit validation |

Multiple domains may apply. For example, reviewing a PR that includes concurrency code should load both code-review.md and concurrency.md.

Step 3: Load and Follow the Reference

Read the selected reference file(s) using ${CLAUDE_SKILL_DIR}/references/<name>.md. Each reference contains the full methodology, phases, code examples, and error handling for that domain. Follow the instructions in the reference as if they were this skill's instructions.

Step 4: Use Domain-Specific Sub-References

Some references point to their own sub-reference files for extended patterns:

Testing sub-references:

${CLAUDE_SKILL_DIR}/references/testing/go-test-patterns.md -- Full table-driven test, helper, mock examples
${CLAUDE_SKILL_DIR}/references/testing/go-benchmark-and-concurrency.md -- b.Loop() benchmarks, synctest

Concurrency sub-references:

${CLAUDE_SKILL_DIR}/references/concurrency/concurrency-patterns.md -- Worker pool, fan-out/fan-in, pipeline, rate limiter, graceful shutdown

Error handling sub-references:

${CLAUDE_SKILL_DIR}/references/error-handling/patterns.md -- gopls tracing, HTTP handler patterns, error wrapping in middleware

Review-pattern sub-references:

${CLAUDE_SKILL_DIR}/references/preferred-patterns/code-examples.md -- Extended before/after for all 7 failure modes

Code review sub-references:

${CLAUDE_SKILL_DIR}/references/code-review/common-review-comments.md -- Go code patterns with good/bad examples

SAP CC conventions sub-references:

${CLAUDE_SKILL_DIR}/references/sapcc-conventions/sapcc-code-patterns.md -- Primary reference: code patterns, testing patterns, failure modes (merged from testing-patterns-detailed.md and preferred-patterns.md)
${CLAUDE_SKILL_DIR}/references/sapcc-conventions/library-reference.md -- Complete approved/restricted library table
${CLAUDE_SKILL_DIR}/references/sapcc-conventions/architecture-patterns.md -- Full 102-rule architecture spec
${CLAUDE_SKILL_DIR}/references/sapcc-conventions/review-standards.md -- Lead + secondary review standards (merged)
${CLAUDE_SKILL_DIR}/references/sapcc-conventions/extended-patterns.md -- Security, K8s, PR hygiene patterns
Plus: api-design-detailed.md, build-ci-detailed.md, error-handling-detailed.md,

go-bits-philosophy-detailed.md, pr-mining-insights.md

Quality gate sub-references:

${CLAUDE_SKILL_DIR}/references/quality-gate/common-lint-errors.json -- Linter descriptions and fix suggestions
${CLAUDE_SKILL_DIR}/references/quality-gate/makefile-targets.json -- Available make targets
${CLAUDE_SKILL_DIR}/references/quality-gate/expert-review-patterns.md -- Manual review patterns
${CLAUDE_SKILL_DIR}/references/quality-gate/examples.md -- Detailed usage examples

Step 5: Execute

Follow the loaded reference methodology. Each reference has its own phases, gates, and completion criteria. Apply them as written.

Available Scripts

Scripts are organized by domain in sub-directories:

Testing: scripts/gen-table-test.sh, scripts/bench-compare.sh
Error handling: scripts/check-errors.sh
Code review: scripts/check-interface-compliance.sh
SAP CC conventions: scripts/check-sapcc-identify-endpoint.sh, scripts/check-sapcc-auth-ordering.sh,

scripts/check-sapcc-json-strict.sh, scripts/check-sapcc-time-now.sh, scripts/check-sapcc-httptest.sh, scripts/check-sapcc-todo-format.sh

Quality gate: scripts/quality_checker.py, scripts/validate.py
Google style snapshot: scripts/sync-google-style-guide.py (pinned upstream refresh; requires review before revision changes)

Error Handling

Errors are domain-specific. Load the relevant reference file and check its Error Handling section for troubleshooting guidance.

Want to see if notque/go-patterns would activate on your phrasing? Try it before you install — no LLM call, no signup.

Latest benchmark · publisher runVerified

8/20/2026, 21:10 UTC · 22 cases

Measured on 17 comparable cases — below the 22 needed to publish a lift, so this result is shown here but not on the registry card or leaderboard.

Lift

-18%

55% vs 73%

Agent turns

0%

1.0 vs 1.0

Tokens

+78%

4,660.94 vs 2,615.24

fail → pass · 2pass → pass · 10fail → fail · 4pass → fail · 6

Per-case results (22)

Case	Status	Duration (ms)			Turns			Tokens			Tool calls
Case	Status	Without	With	Δ	Without	With	Δ	Without	With	Δ	Without	With	Δ
case-08 Write a Go HTTP POST handler function for a JSON payload API in an SAP CC microservice project (`sapcc/keystone-proxy`). The payload deserializes into a struct. Ensure strict validation against unknown JSON fields.	fail→fail	12,899	15,460	+20%	1	1	0%	2,433	4,810	+98%	0	0	—
case-09 Provide a Go `main` function pattern that starts an HTTP server on port 8080 and listens for SIGINT or SIGTERM signals to perform a graceful shutdown within a 10-second timeout window.	pass→pass	7,156	15,402	+115%	1	1	0%	1,381	4,773	+246%	0	0	—
case-01 I need to implement a Go background worker pool that processes incoming job payloads with configurable throughput limits and graceful shutdown handling. Please provide the full Go source code for this component, formatted cleanly with inline comments explaining the error handling and concurrency choices.	fail→fail	29,746	46,271	+56%	1	1	0%	5,422	7,341	+35%	0	0	—
case-02 Please review this Go pull request from our repository under the sapcc organization. Inspect the code for potential race conditions, unhandled error wrapping, and style violations. Output your evaluation as a structured code review report that lists major findings, minor recommendations, and specific refactoring snippets.	pass→fail	17,758	7,653	-57%	1	1	0%	3,010	2,438	-19%	0	0	—
case-03 I need to add unit and benchmark tests for my Go data transformation module and run a pre-commit check on it. Please write table-driven test suites using idiomatic helper functions, add standard benchmark tests, and outline the output of the validation sequence. Output the complete test source file followed by a summary of the validation checks.	fail→fail	28,344	27,031	-5%	1	1	0%	6,206	7,100	+14%	0	0	—
case-04 Write a concurrent pipeline in Go that accepts a channel of data items, processes them across 4 worker goroutines, and returns a results channel. Maintain context cancellation support. Please output the complete Go implementation.	fail→pass	15,294	16,952	+11%	1	1	0%	2,968	5,030	+69%	0	0	—
case-05 I have an HTTP handler in Go that calls a repository function. If the database returns `sql.ErrNoRows`, I want to return a custom `NotFoundError` HTTP status while keeping the underlying cause attached. Show the Go function for parsing and wrapping this database error.	fail→pass	11,119	17,811	+60%	1	1	0%	2,000	5,249	+162%	0	0	—
case-06 We are refactoring legacy Go code that defines custom type aliases and enum-like constants. Show the recommended idiomatic Go pattern for defining a `Status` type with constants `StatusPending`, `StatusActive`, and `StatusClosed`, including a method to validate the status value.	pass→pass	11,139	15,731	+41%	1	1	0%	2,009	4,165	+107%	0	0	—
case-07 Write a unit test file in Go for a string sanitizer function `SanitizeUserString(s string) (string, error)`. Provide a table-driven test with multiple test cases.	fail→fail	12,748	24,552	+93%	1	1	0%	2,494	6,197	+148%	0	0	—
case-10 I have a Go package where I defined `type DataProcessor interface { Process(data string) string }` and only one concrete implementation `type defaultProcessor struct{}`. How should this be structured in idiomatic Go? Provide the refactored code.	pass→fail	11,571	5,413	-53%	1	1	0%	1,864	2,297	+23%	0	0	—
case-11 In an SAP CC service codebase, we need to generate timestamps inside a domain model method for created/updated fields. Show the recommended pattern for timestamp creation that supports deterministic testing.	pass→fail	16,767	4,279	-74%	1	1	0%	2,985	2,444	-18%	0	0	—
case-12 We want to set up local validation before opening a PR on our Go service repository. List the typical sequence of static analysis and test validation steps to run, along with the standard Makefile target invoked in Go repositories.	pass→pass	13,941	12,545	-10%	1	1	0%	2,439	3,729	+53%	0	0	—
case-13 Create a custom Go error type `ValidationError` that holds a field name and a validation message, and implements the standard `error` interface as well as the `Unwrap` method.	pass→fail	8,917	4,742	-47%	1	1	0%	1,599	2,139	+34%	0	0	—
case-14 Show how to test a Go service function `GetUserProfile(ctx context.Context, id string) (*User, error)` without using heavy third-party mocking frameworks like `gomock` or `testify/mock`.	pass→pass	13,799	14,923	+8%	1	1	0%	2,649	4,522	+71%	0	0	—
case-15 In a Go API handler returning a list of items in JSON format (`[]Item`), how should empty slice results be initialized before serialization to avoid returning `null` in JSON responses? Provide the Go code snippet.	pass→fail	6,699	6,912	+3%	1	1	0%	1,276	2,213	+73%	0	0	—
case-16 Provide a Go function signature and implementation for fetching remote configuration parameters that requires context cancellation and timeout control. Demonstrate where the `ctx` parameter belongs.	pass→pass	12,160	12,885	+6%	1	1	0%	2,264	4,066	+80%	0	0	—
case-17 Review this Go code snippet: ```go func SaveData(path string, data []byte) error { f, _ := os.Create(path) defer f.Close() f.Write(data) return nil } ``` Provide a code review critique and the corrected Go function.	pass→pass	10,417	17,564	+69%	1	1	0%	1,910	4,251	+123%	0	0	—
case-18 Write a Go benchmark function for testing a JSON parsing routine `ParsePayload(b []byte)`. Show the benchmark implementation using modern Go benchmark loop constructs.	pass→pass	8,173	14,501	+77%	1	1	0%	1,384	3,741	+170%	0	0	—
case-19 In an SAP CC web service using `go-bits` HTTP middleware, show the correct ordering sequence for authentication, authorization, request logging, and rate limiting middleware wrapped around an HTTP router.	pass→fail	15,253	6,055	-60%	1	1	0%	2,355	2,283	-3%	0	0	—
case-20 How do I implement custom error handling and the `std::error::Error` trait for an enum error type in Rust?	pass→pass	12,624	11,207	-11%	1	1	0%	2,327	3,853	+66%	0	0	—
case-21 How do I implement a background worker queue with concurrency limits using Python's `asyncio` module?	pass→pass	13,835	14,898	+8%	1	1	0%	2,456	4,620	+88%	0	0	—
case-22 Provide a Kubernetes Deployment YAML manifest for running a web service with 3 replicas, resource limits, and a liveness probe on `/healthz`.	pass→pass	6,036	7,948	+32%	1	1	0%	1,132	3,345	+195%	0	0	—

These cases were also screened by the skill’s intent / safety pass.See the Trust review ↗Reproduce this benchmark in Colab ↗

How this skill was measured

DecimalAI ran this skill against gemini-3.6-flash twice over the same eval suite — once with the skill loaded and once without — and compared the two runs case by case. 22 cases were attempted, and 17 counted toward the lift figure. The other 5 produced results that are not comparable between the two arms, so they are excluded from the headline rather than averaged into it. The headline lift of -18 percentage points is the difference between those two pass rates over the 17 comparable cases. 6 cases got worse with the skill loaded, and they are included in that figure.

Model measured: gemini-3.6-flash
Graded by: gemini-3.6-flash
Grading method: judged
Verification: verified
Pass rate without the skill: 72.7%
Pass rate with the skill: 54.6%
Cases attempted: 22
Cases counted toward lift: 17
Cases that regressed: 6
Skill version measured: v2
Run completed: 8/20/2026, 21:10 UTC

Measured example — same prompt, with vs. without the skill · from the benchmark run · case case-04

Prompt

Write a concurrent pipeline in Go that accepts a channel of data items, processes them across 4 worker goroutines, and returns a results channel. Maintain context cancellation support. Please output the complete Go implementation.

Without the skill loaded, the model failed this case. With it loaded, the same prompt on the same model passed. This is one improved case from the latest verified run; every case, including any that regressed, is in the table above.

Show both answers

SkillScore blends 4 signalsno signals yet

BenchmarkRun a verified benchmark with positive lift

Live evalNeeds ≥20 evaluated traces in 30 days

AI ratingNeeds ≥10 rated traces

AdoptionNeeds ≥10 serves across ≥2 orgs in 30 days

No signals yet — run a benchmark or collect evaluated traces to earn a score.

Verified on gemini-3.6-flash · re-tested today

Other measured skills in the registry, with their headline benchmark lift.