golang-samber-lo
Functional programming helpers for Golang using samber/lo — 500+ type-safe generic functions for slices, maps, channels, strings, math, tupl
Open source Repository Open in the app JSON README (API)
About
Functional programming helpers for Golang using samber/lo — 500+ type-safe generic functions for slices, maps, channels, strings, math, tuples, and concurrency (Map, Filter, Reduce, GroupBy, Chunk, Flatten, Find, Uniq, etc.). Core immutable package (lo), concurrent variants (lo/parallel aka lop), in-place mutations (lo/mutable aka lom), lazy iterators (lo/it aka loi for Go 1.23+), and experimental SIMD (lo/exp/simd). Apply when using or adopting samber/lo, when the codebase imports github.com/samber/lo, or when implementing functional-style data transformations in Go. Not for streaming pipelines (→ See `samber/cc-skills-golang@golang-samber-ro` skill).
Details
- Kind
- Agent skills
- Topic
- Maps, weather & travel
- Publisher
- samber
- Origin
- skillssh
- Category
- ferramentas
- Stars
- 3,173
- Forks
- 206
- Open pull requests
- 1
- Last push
- 2026-09-05T00:59:38Z
- Repository state
- ativo
- Language
- Go
- License
- MIT
- Added
- 2026-08-30 15:21:09
- Updated
- 2026-09-08 18:02:36
- Origin id
samber/cc-skills-golang/golang-samber-lo
README
# Agent Skills for production-ready Golang projects
AI agent skills are reusable instruction sets that extend your coding assistant with domain-specific expertise, loaded on demand so they don't bloat your context. This repository covers **Go-specific** skills only (language, testing, security, observability, etc.); for dev workflow skills (git conventions, CI/CD, PR reviews) you'll want to add a separate skills plugin.
For non-Golang skills, please visit [cc-skills](https://github.com/samber/cc-skills).
<!-- prettier-ignore-start -->
> [!IMPORTANT]
> Bootstrapped with Claude Code by distilling my Go project commits. **Edited, tested, reviewed and reworked by a human**.
>
> **No AI slop here.** AI-made skills are useless.
>
> Built for Claude Code, Codex, Gemini, Copilot, Antigravity, Cursor...
<!-- prettier-ignore-end -->
<img width="1414" height="491" alt="image" src="https://github.com/user-attachments/assets/620b5835-c1ba-4ea9-bf47-2293b58b879e" />
## 🚀 How to use
**Install with [skills](https://skills.sh/) CLI** (universal, works with any [Agent Skills](https://agentskills.io)-compatible tool):
```bash
npx skills add https://github.com/samber/cc-skills-golang --all
# or a single skill:
npx skills add https://github.com/samber/cc-skills-golang --skill golang-performance
```
<!-- prettier-ignore-start -->
<details>
<summary>Claude Code</summary>
```bash
/plugin marketplace add samber/cc
/plugin install cc-skills-golang@samber
```
</details>
<details>
<summary>Openclaw</summary>
Copy skills into the cross-client discovery directory:
```bash
git clone https://github.com/samber/cc-skills-golang.git ~/.openclaw/skills/cc-skills-golang
# or in workspace:
git clone https://github.com/samber/cc-skills-golang.git ~/.openclaw/workspace/skills/cc-skills-golang
```
</details>
<details>
<summary>Gemini CLI</summary>
```bash
gemini extensions install https://github.com/samber/cc-skills-golang
```
Update with `gemini extensions update cc-skills-golang`.
</details>
<details>
<summary>Cursor</summary>
Copy skills into the cross-client discovery directory:
```bash
git clone https://github.com/samber/cc-skills-golang.git ~/.cursor/skills/cc-skills-golang
```
Cursor auto-discovers skills from `.agents/skills/` and `.cursor/skills/`.
</details>
<details>
<summary>Copilot</summary>
Copy skills into the cross-client discovery directory:
```bash
/plugin install https://github.com/samber/cc-skills-golang
# or
git clone https://github.com/samber/cc-skills-golang.git ~/.copilot/skills/cc-skills-golang
```
Copilot auto-discovers skills from `.copilot/skills/`.
</details>
<details>
<summary>OpenCode</summary>
Copy skills into the cross-client discovery directory:
```bash
git clone https://github.com/samber/cc-skills-golang.git ~/.agents/skills/cc-skills-golang
```
OpenCode auto-discovers skills from `.agents/skills/`, `.opencode/skills/`, and `.claude/skills/`.
</details>
<details>
<summary>Codex (OpenAI)</summary>
Clone into the cross-client discovery path:
```bash
git clone https://github.com/samber/cc-skills-golang.git ~/.agents/skills/cc-skills-golang
```
Codex auto-discovers skills from `~/.agents/skills/` and `.agents/skills/`. Update with `cd ~/.agents/skills/cc-skills-golang && git pull`.
</details>
<details>
<summary>Antigravity</summary>
Clone and symlink into the cross-client discovery path:
```bash
git clone https://github.com/samber/cc-skills-golang.git ~/.antigravity/skills/cc-skills-golang
```
Update with `cd ~/.antigravity/skills/cc-skills-golang && git pull`.
</details>
<!-- prettier-ignore-end -->
## 🧩 Skills
These skills are designed as **atomic, cross-referencing units**. A skill may reference conventions defined in another (e.g. error-handling rules that affect logging live in `golang-error-handling`, not `golang-observability`). Installing only a subset will give you a partial and potentially inconsistent view of the guidelines. For best results, install all general-purpose skills together.
```
┌────────────────────────────────────────┐
│ Golang Skills │
└──────────────────┬─────────────────────┘
│
┌─────────────────┬──────────────────────┼──────────────────────┐
▼ ▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌─────────────────┐ ┌──────────────────────┐
│ Code Quality │ │ Arch & Design│ │ QA & Perf │ │ Project Start │
├──────────────┤ ├──────────────┤ ├─────────────────┤ ├──────────────────────┤
│ code-style │ │ design-patt │ │ testing │ │ project-layout │
│ naming │ │ concurrency │ │ benchmark │ │ popular-libs │
│ error-handl │ │ context │ │ performance │ │ cli │
│ safety │ │ dep-inject │ │ troubleshoot │ │ continuous-integ. │
│ structs-iface│ │ data-structs │ │ observability │ │ stay-updated │
│ documentation│ │ database │ │ │ │ dep-management │
│ lint │ │ modernize │ │ │ │ gopls │
│ security │ │ refactoring │ │ │ │ pkg-go-dev │
└──────────────┘ └──────────────┘ └─────────────────┘ └──────────────────────┘
┌─────────────────────────────────────────────────────────────────────────┐
│ Framework / Library Skills │
├──────────────┬────────────────┬──────────────┬─────────────┬───────────┤
│ APIs │ DI │ Frameworks │ samber/* │ Testing │
├──────────────┼────────────────┼──────────────┼─────────────┼───────────┤
│ grpc │ google-wire │ spf13-cobra │ samber-lo │ stretchr- │
│ graphql │ uber-dig │ spf13-viper │ samber-mo │ testify │
│ swagger │ uber-fx │ │ samber-ro │ │
│ │ │ │ samber-do │ │
│ │ │ │ samber-hot │ │
│ │ │ │ samber-slog │ │
│ │ │ │ samber-oops │ │
└──────────────┴────────────────┴──────────────┴─────────────┴───────────┘
```
- ⭐️ Recommended
- ✅ Published
- 👷 Work in progress
- ❌ To-do
- ⚡ Command available
- 🧠 Ultrathink automatically
- 🤖 Ultracode automatically
- ⚙️ Overridable (see doc below)
- **Description (tok)**: weight of the `description` field from YAML frontmatter, always loaded into Claude's context for skill triggering
- **SKILL.md (tok)**: weight of the full `SKILL.md` file loaded when the skill triggers
- **Directory (tok)**: weight of all files in the skill directory (SKILL.md + referenced markdown files)
**General purpose:**
<!-- markdownlint-disable table-column-style -->
| | Skill | Flags | Error rate gap | Description (tok) | SKILL.md (tok) | Directory (tok) |
| --- | --- | --- | --- | --- | --- | --- |
| ⭐️ | ✅ `golang-code-style` | ⚡ 🤖 ⚙️ | -40% | 114 | 2,358 | 2,974 |
| ⭐️ | ✅ `golang-data-structures` | ⚡ | -39% | 93 | 2,608 | 6,327 |
| ⭐️ | ✅ `golang-database` | ⚡ ⚙️ | -38% | 97 | 2,721 | 7,243 |
| ⭐️ | ✅ `golang-design-patterns` | ⚡ ⚙️ | -37% | 80 | 2,694 | 9,400 |
| ⭐️ | ✅ `golang-documentation` | ⚡ 🤖 ⚙️ | -53% | 75 | 3,163 | 11,876 |
| ⭐️ | ✅ `golang-error-handling` | ⚡ 🤖 ⚙️ | -26% | 141 | 1,734 | 4,693 |
| ⭐️ | ✅ `golang-how-to` | ⚡ | — | 184 | 4,210 | 17,583 |
| ⭐️ | ✅ `golang-modernize` | ⚡ 🤖 | -43% | 104 | 3,486 | 15,145 |
| ⭐️ | ✅ `golang-naming` | ⚡ ⚙️ | -23% | 159 | 3,031 | 7,399 |
| ⭐️ | ✅ `golang-refactoring` | ⚡ 🧠 🤖 ⚙️ | — | 245 | 3,835 | 20,392 |
| ⭐️ | ✅ `golang-safety` | ⚡ | -58% | 78 | 2,614 | 5,384 |
| ⭐️ | ✅ `golang-testing` | ⚡ 🧠 🤖 ⚙️ | -32% | 115 | 4,270 | 8,822 |
| ⭐️ | ✅ `golang-troubleshooting` | ⚡ 🧠 🤖 | -32% | 173 | 2,993 | 18,035 |
| ⭐️ | ✅ `golang-security` | ⚡ 🧠 🤖 | -32% | 85 | 3,187 | 21,623 |
| | ✅ `golang-benchmark` | ⚡ 🧠 | -50% | 102 | 3,153 | 33,396 |
| | ✅ `golang-cli` | ⚡ | -43% | 125 | 2,338 | 6,153 |
| | ✅ `golang-concurrency` | ⚡ 🤖 ⚙️ | -39% | 72 | 2,196 | 6,826 |
| | ✅ `golang-context` | ⚡ ⚙️ | -34% | 82 | 1,211 | 4,021 |
| | ✅ `golang-continuous-integration` | ⚡ | -59% | 177 | 3,542 | 12,804 |
| | ✅ `golang-dependency-injection` | ⚡ 🤖 ⚙️ | -47% | 178 | 3,016 | 5,287 |
| | ✅ `golang-dependency-management` | ⚡ | -54% | 77 | 2,407 | 5,545 |
| | ✅ `golang-structs-interfaces` | ⚡ ⚙️ | -35% | 111 | 3,076 | 3,076 |
| | ✅ `golang-lint` | ⚡ 🤖 | -41% | 98 | 1,877 | 6,295 |
| | ✅ `golang-observability` | ⚡ 🤖 ⚙️ | -37% | 164 | 3,128 | 19,583 |
| | ✅ `golang-performance` | ⚡ 🧠 🤖 | -39% | 130 | 2,226 | 19,820 |
| | ✅ `golang-gopls` | ⚡ | — | 219 | 2,317 | 12,312 |
| | ✅ `golang-pkg-go-dev` | ⚡ | — | 170 | 3,442 | 5,386 |
| | ✅ `golang-popular-libraries` | ⚡ | -30% | 156 | 1,181 | 5,093 |
| | ✅ `golang-project-layout` | ⚡ | -38% | 105 | 1,761 | 6,257 |
| | ✅ `golang-stay-updated` | ⚡ | -56% | 44 | 1,802 | 1,802 |
**Tools:**
| Skill | Flags | Error rate gap | Description (tok) | SKILL.md (tok) | Directory (tok) |
| --- | --- | --- | --- | --- | --- |
| ✅ `golang-google-wire` | ⚡ | -16% | 122 | 2,670 | 7,400 |
| ✅ `golang-graphql` | | -16% | 76 | 3,070 | 7,941 |
| ✅ `golang-grpc` | ⚡ | -41% | 70 | 2,341 | 5,157 |
| ✅ `golang-spf13-cobra` | ⚡ | — | 176 | 2,580 | 7,351 |
| ✅ `golang-spf13-viper` | ⚡ | — | 170 | 2,551 | 7,098 |
| ✅ `golang-swagger` | ⚡ | — | 144 | 2,342 | 3,347 |
| ✅ `golang-uber-dig` | ⚡ | -10% | 107 | 2,585 | 6,257 |
| ✅ `golang-uber-fx` | ⚡ | -5% | 118 | 2,825 | 7,060 |
| ✅ `golang-samber-do` | ⚡ | -81% | 71 | 2,145 | 3,660 |
| ✅ `golang-samber-hot` | ⚡ | -54% | 119 | 1,986 | 7,416 |
| ✅ `golang-samber-lo` | ⚡ | -40% | 166 | 2,610 | 10,288 |
| ✅ `golang-samber-mo` | ⚡ 🧠 | -48% | 82 | 2,967 | 11,382 |
| ✅ `golang-samber-oops` | ⚡ | -59% | 70 | 2,544 | 2,856 |
| ✅ `golang-samber-ro` | ⚡ 🧠 | -50% | 153 | 2,976 | 11,192 |
| ✅ `golang-samber-slog` | ⚡ | -19% | 119 | 3,120 | 9,842 |
| ❌ `golang-temporal` | | — | 0 | 0 | 0 |
| ✅ `golang-stretchr-testify` | ⚡ | -47% | 92 | 1,858 | 2,677 |
## 🧪 Skill evaluations
| | With Skill | Without Skill | Delta |
| ----------- | ------------------- | ------------------- | --------- |
| **Overall** | **3348/3439 (97%)** | **1957/3439 (57%)** | **+40pp** |
See [EVALUATIONS.md](./EVALUATIONS.md) for the full per-skill breakdown.
## 📖 Skills description
### Code Quality
#### `golang-code-style`
Go code formatting and conventions. gofmt, goimports, linting rules, comment conventions, and project-level style consistency. Overridable by company skills.
#### `golang-documentation`
Go documentation standards. Package docs, godoc conventions, code comments, example functions, README structure, and API reference generation. Overridable.
#### `golang-error-handling`
Go error handling best practices. Error creation, wrapping with fmt.Errorf and errors.Is/As, sentinel errors, custom error types, error codes, and panic recovery. Overridable.
#### `golang-lint`
Go linting best practices and golangci-lint configuration. Presets, custom rules, CI integration, inline suppression, and output interpretation.
#### `golang-naming`
Go naming conventions across all identifier types. Packages, constructors, structs, interfaces, constants, errors, receivers, acronyms, test functions. Covers MixedCaps rules, Get-prefix, and utils/helpers anti-patterns. Overridable.
#### `golang-safety`
Defensive Go coding. Prevents panics, silent data corruption, and runtime bugs. nil safety, append aliasing, map concurrent access, float comparison, zero-value design, numeric overflow.
#### `golang-security`
Go security best practices. Injection prevention (SQL, command, XSS), cryptography, filesystem/network safety, secrets management, cookie security, and tool configuration. Audit and review modes.
#### `golang-structs-interfaces`
Go struct and interface design. Composition, embedding, type assertions, interface segregation, struct tags (JSON/YAML/DB), pointer vs value receivers. Overridable.
### Architecture & Design
#### `golang-concurrency`
Go concurrency patterns. Goroutines, channels, sync primitives, context cancellation, worker pools, fan-out/fan-in, pipelines. Overridable.
#### `golang-context`
Idiomatic context.Context usage. Creation, cancellation, timeouts, values, propagation patterns, and common anti-patterns. Overridable.
#### `golang-data-structures`
Go data structures internals and usage. Slices (capacity growth, append aliasing), maps, channels, sync primitives, and when to use each.
#### `golang-database`
Go database access patterns. Parameter binding, connection pooling, transactions, migrations, sqlboiler/sqlc code generation, query builders. Overridable.
#### `golang-dependency-injection`
Dependency injection patterns in Go. Constructor injection, interface-based DI, wire/dig/fx comparison, and when DI is worth the complexity. Overridable.
#### `golang-design-patterns`
Idiomatic Go design patterns. Functional options, constructors, builder pattern, middleware chains, circuit breaker, and architecture guides with file trees and code. Overridable.
#### `golang-modernize`
Modernize Go code to use recent language features. Range-over-int, min/max builtins, iterators, slices/maps/cmp/slog stdlib packages, testing patterns (t.Context, b.Loop, synctest), and tooling upgrades.
#### `golang-refactoring`
Safe, at-scale refactoring process for existing Go code. Coverage-adaptive safety net, tool-driven behavior-preserving transforms (gopls Rename/Inline/Extract, gofmt -r, eg, gopatch), the Fowler catalog mapped to Go, breaking import cycles, type-alias gradual code repair, and a human-in-the-loop workflow of staged PRs on a refactoring branch.
### QA & Performance
#### `golang-benchmark`
Go benchmarking, profiling, and performance measurement. pprof, trace, CPU/memory/block profiles, flame graphs, benchmark comparison (benchstat), continuous profiling.
#### `golang-observability`
Go production observability. Structured logging (slog), Prometheus metrics, OpenTelemetry tracing, pprof profiling, RUM tracking, alerting, Grafana dashboards. Overridable.
#### `golang-performance`
Go performance optimization. Allocation reduction, CPU efficiency, memory layout, GC tuning, pooling, caching, hot-path optimization. Review and hot-path modes.
#### `golang-testing`
Production-ready Go tests. Table-driven tests, fuzzing, fixtures, goroutine leak detection (goleak), snapshot testing, code coverage, integration tests, parallel tests. Overridable.
#### `golang-troubleshooting`
Systematic Go debugging methodology. Common pitfalls, test-driven debugging, pprof capture, Delve debugger, race detection, GODEBUG tracing, production debugging.
### Project Setup
#### `golang-cli`
Go CLI application development. Project layout, exit codes, signal handling, I/O patterns, argument parsing, and terminal UX.
#### `golang-continuous-integration`
CI/CD pipeline configuration for Go projects using GitHub Actions. Build, test, lint, and release workflows.
#### `golang-dependency-management`
Go module dependency strategies. go.mod conventions, versioning, replace directives, tool dependencies, and multi-module workspaces.
#### `golang-gopls`
Semantic code intelligence for your local build via `gopls`, the official Go language server. Go-to-definition, find references, call/implementation hierarchy, workspace symbol search, diagnostics, safe rename, and refactors (extract/inline/fill/rewrite). Reachable via gopls's own MCP server, Claude Code's native `LSP` tool, or the `gopls` CLI.
#### `golang-pkg-go-dev`
Go package and module exploration via `godig`, a pkg.go.dev API client (CLI + MCP server). Package docs, API references, symbols, code examples, versions, importers, licenses, and known vulnerabilities. Prefer over Context7 for Go packages.
#### `golang-popular-libraries`
Curated recommendations for production-ready Go libraries and frameworks. When the stdlib is enough vs when to reach for a package.
#### `golang-project-layout`
Go project structure and workspace setup. cmd/internal/pkg conventions, monorepo layout, CLI project structure, and when to keep things flat.
#### `golang-stay-updated`
Resources to stay current with Go. Official channels, community hubs, key people to follow, and learning resources.
### APIs
#### `golang-graphql`
GraphQL API development in Go using gqlgen/graphql-go. Schema definition, resolvers, subscriptions, dataloader, and federation.
#### `golang-grpc`
gRPC in Go. Protobuf organization, service definitions, streaming, interceptors, error codes, and code generation workflow.
#### `golang-swagger`
OpenAPI/Swagger docs with swaggo/swag. Annotation comments, code generation, framework integrations (gin, echo, fiber, chi), security definitions.
### Dependency Injection
#### `golang-google-wire`
Compile-time dependency injection with google/wire. Provider sets, injector generation, wire.Build, and structured DI patterns.
#### `golang-uber-dig`
Reflection-based DI with uber-go/dig. Provide/Invoke, dig.In/dig.Out, named values, value groups, optional dependencies, and Decorate.
#### `golang-uber-fx`
Application framework with uber-go/fx. fx.New, fx.Provide/Invoke, fx.Module, lifecycle hooks, fx.Annotate, fx.Decorate, signal-aware Run.
### Frameworks
#### `golang-spf13-cobra`
CLI command trees with spf13/cobra. Command hierarchy, RunE hooks, flag management, shell completion, usage templates, and testing with SetArgs.
#### `golang-spf13-viper`
Layered configuration with spf13/viper. Flag > env > file > KV > default precedence, BindPFlag, hot reload, test isolation, and remote KV integration.
### samber/\*
#### `golang-samber-do`
Dependency injection with samber/do. Type-safe service containers, lifecycle management, scopes, health checks, and graceful shutdown.
#### `golang-samber-hot`
In-memory caching with samber/hot. 9 eviction algorithms (LRU, LFU, TinyLFU, W-TinyLFU, S3FIFO, ARC, SIEVE...), TTL, loaders, sharding, stale-while-revalidate, Prometheus metrics.
#### `golang-samber-lo`
Functional programming helpers with samber/lo. 500+ type-safe generic functions for slices, maps, channels, strings. Immutable (lo), parallel (lop), mutable (lom), iterators (loi), SIMD.
#### `golang-samber-mo`
Monadic types with samber/mo. Option, Result, Either, Future, IO, Task, State for type-safe nullable values, error handling, and functional composition.
#### `golang-samber-oops`
Structured error handling with samber/oops. Error builders, stack traces, error codes, context attributes, public vs developer messages, panic recovery, and APM integration.
#### `golang-samber-ro`
Reactive streams with samber/ro. 150+ type-safe operators, cold/hot observables, 5 subject types, 40+ plugins, automatic backpressure, and Go context integration.
#### `golang-samber-slog`
Structured logging pipeline with samber/slog-\*\*\*\* packages. Multi-handler routing (slog-multi), sampling, formatting, HTTP middleware, and 20+ backend sinks.
### Testing
#### `golang-stretchr-testify`
Testing with stretchr/testify. assert, require, mock, and suite packages. Assertions, mock expectations, argument matchers, suite lifecycle, and custom matchers.
## 🕵 Use in CI for AI-driven reviews
Add AI agents as PR reviewers alongside traditional static analysis. When configured with this skill plugin, the agent applies the relevant Go skills per review area — catching architectural drift, logic bugs, and concurrency hazards that linters cannot detect.
See [GOLANG-AI-DRIVEN-REVIEW.md](./GOLANG-AI-DRIVEN-REVIEW.md) for full setup instructions (Claude Code Action and GitHub Copilot).
## 🎯 Tuning Skill Triggers
If a skill triggers too often or not often enough, please [open an issue](https://github.com/samber/cc-skills-golang/issues) suggesting a description change. The `description` field in SKILL.md frontmatter is the primary triggering mechanism — small wording adjustments can significantly improve trigger accuracy. Some `SKILL.md` files might have a `When to use` section which is another level of exclusion. Finally, `SKILL.md` files are an entrypoint for lazy loading references with deep knowledge located in `references/`.
## 🔄 Overlap
Claude reports very little overlap between skills in this repo, thanks to cross-reference. I suggest enabling most of the skills and leveraging lazy loading. The recommended ⭐️ skills load ~1,100 tokens of descriptions at startup; full skill content is only pulled in when relevant. Note:
- I estimate that 50% of `golang-naming` and `golang-code-style` overlap with linters (golangci-lint).
- A large part of the security rules in `golang-security` have been distilled from the Bearer (SAST) checklist. The skill is still useful for methodology.
- If your team has its own conventions, create a company skill and declare the override explicitly near the top of its body: `This skill supersedes samber/cc-skills-golang@golang-naming skill for [company] projects.` Skills marked ⚙️ in the table above support this mechanism.
## ✍️ Contribute
- **100 tokens per skill description** - what? when to use this skill?
- **1.000–2.500 tokens per SKILL.md** — keep the main file focused on essentials
- **Use secondary markdown files for depth** — reference them from SKILL.md with relative links (e.g., `[Logging](./logging.md)`). Claude reads these on demand when the topic is relevant, so they don't count against the context budget until needed
- **Up to 10.000 tokens** for full skill and secondary files
- **2–4 skills loaded simultaneously** in a typical session — design skills to coexist
- **Stay below ~10k tokens of total loaded SKILL.md** anytime to avoid degrading response quality
For more guidelines, please check `CLAUDE.md`.
## 💫 Fuel the Revolution
- ⭐️ **Star this repo** - Your star powers the caffeine engine!
- ☕️ **Buy me a coffee** - I'll literally use it to build more skills while drinking actual coffee
[](https://github.com/sponsors/samber)
## 📝 License
Copyright © 2026 [Samuel Berthe](https://github.com/samber).
This project is under [MIT](./LICENSE) license.