Agent skill
go-performance
Use when writing, reviewing, or optimizing Go code for performance. Covers string operations, memory allocation, preallocating slices and maps, strings.Builder, strconv, container-aware GOMAXPROCS, and runtime considerations for Go 1.25.
Install this agent skill to your Project
npx add-skill https://github.com/saisudhir14/claude-skills/tree/main/skills/go-performance
Metadata
Additional technical details for this skill
- tags
- golang go performance optimization memory allocation
- author
- saisudhir14
- category
- languages
SKILL.md
Go Performance
Performance optimization patterns for production Go.
Prefer strconv Over fmt
strconv is faster for primitive conversions.
// Slower
s := fmt.Sprintf("%d", n)
// Faster
s := strconv.Itoa(n)
Avoid Repeated String to Byte Conversions
// Wrong: converts on every iteration
for i := 0; i < n; i++ {
w.Write([]byte("hello"))
}
// Correct
data := []byte("hello")
for i := 0; i < n; i++ {
w.Write(data)
}
Specify Map Capacity
// Wrong
m := make(map[string]int)
// Correct when size is known
m := make(map[string]int, len(items))
Preallocate Slice Capacity
// Wrong
var result []Item
for _, v := range input {
result = append(result, transform(v))
}
// Correct
result := make([]Item, 0, len(input))
for _, v := range input {
result = append(result, transform(v))
}
Use strings.Builder for Concatenation
// Wrong: creates many allocations
var s string
for _, part := range parts {
s += part
}
// Correct
var b strings.Builder
b.Grow(totalLen) // optional: preallocate
for _, part := range parts {
b.WriteString(part)
}
s := b.String()
Container-Aware GOMAXPROCS (Go 1.25+)
Go 1.25 automatically adjusts GOMAXPROCS based on container CPU limits.
// On Linux with cgroups, GOMAXPROCS now considers:
// - CPU bandwidth limits (CPU limit in Kubernetes)
// - Changes dynamically if limits change
// Automatic behavior is disabled if you set GOMAXPROCS explicitly:
// - Via GOMAXPROCS environment variable
// - Via runtime.GOMAXPROCS() call
This means Go programs in containers perform better out-of-the-box without manual GOMAXPROCS tuning.
Resource Management (Go 1.24+)
runtime.AddCleanup
Prefer runtime.AddCleanup over runtime.SetFinalizer for cleanup operations.
func NewResource() *Resource {
r := &Resource{handle: allocHandle()}
runtime.AddCleanup(r, func(handle uintptr) {
freeHandle(handle)
}, r.handle)
return r
}
Advantages over SetFinalizer:
- Multiple cleanups per object
- Works with interior pointers
- No cycle-related leaks
- Object freed promptly (single GC cycle)
Weak Pointers (Go 1.24+)
The weak package provides weak references that don't prevent garbage collection.
import "weak"
type Cache struct {
mu sync.Mutex
items map[string]weak.Pointer[ExpensiveResource]
}
func (c *Cache) Get(key string) *ExpensiveResource {
c.mu.Lock()
defer c.mu.Unlock()
if wp, ok := c.items[key]; ok {
if r := wp.Value(); r != nil {
return r
}
delete(c.items, key)
}
return nil
}
Use cases: caches, canonicalization maps, observer patterns.
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
saisudhir14/claude-skills
go-project-layout
Use when starting a new Go project, organizing packages, or restructuring an existing Go codebase. Covers standard directory layout, package design, Makefile targets, Dockerfile patterns, and module setup.
saisudhir14/claude-skills
go-code-review
Use when reviewing Go code or preparing code for review. Quick-reference checklist covering naming, error handling, concurrency, testing, imports, documentation, and common pitfalls. Based on Go Wiki CodeReviewComments.
saisudhir14/claude-skills
go-concurrency
Use when writing, reviewing, or debugging concurrent Go code. Covers goroutine lifecycle management, channels, errgroup, mutexes, atomics, sync.Map, and synchronous-first design. Based on Google and Uber style guides.
saisudhir14/claude-skills
go-security
Use when writing, reviewing, or auditing Go code for security. Covers input validation, SQL injection prevention, path traversal, secrets management, cryptography, HTTP security headers, and dependency scanning.
saisudhir14/claude-skills
go-error-handling
Use when writing, reviewing, or debugging Go error handling code. Covers error wrapping, sentinel errors, custom error types, error joining, single handling, and error flow patterns. Based on Google and Uber style guides.
saisudhir14/claude-skills
go-testing
Use when writing, reviewing, or debugging Go tests and benchmarks. Covers table-driven tests, parallel execution, go-cmp, T.Context, T.Chdir, b.Loop, synctest for deterministic concurrency testing, and test failure messages.
Didn't find tool you were looking for?