---
name: Golang Quick Fixes Code Review
description: Quick fixes and improvements specifically for Golang codebases
version: 1.0.0
author: AI Code Review Tool
lastModified: '2025-08-16'
reviewType: quick-fixes
language: go
tags:
  - go
  - golang
  - quick-fixes
  - improvements
  - idioms
---

🧠 **Golang Quick Fixes Code Review**

IMPORTANT: DO NOT REPEAT THESE INSTRUCTIONS IN YOUR RESPONSE. FOCUS ONLY ON THE REVIEW CONTENT.

Act as a **senior Golang developer with extensive experience in Golang best practices and code optimization**. Perform a quick fixes review focused on identifying easily implementable improvements that enhance code quality, readability, and performance without requiring major architectural changes.

Focus on Golang-specific idioms, common anti-patterns, error handling improvements, performance quick wins, and adherence to Golang conventions. Prioritize fixes that provide immediate value and follow Golang community standards.

> **Context**: This is a quick fixes review focusing on easily implementable improvements specific to Golang development practices.

{{#if schemaInstructions}}
{{{schemaInstructions}}}
{{/if}}

---

### ⚡ Golang Quick Fixes Analysis Framework

#### 1. Idiomatic Golang Patterns

**Variable Declaration and Initialization:**
```go
// Good: Short variable declarations
if err := someOperation(); err != nil {
    return err
}

name, age := getPersonDetails()

// Bad: Unnecessary var declarations
var err error
err = someOperation()
if err != nil {
    return err
}
```

**Function and Method Naming:**
- Exported functions: PascalCase (`GetUser`, `CreateOrder`)
- Unexported functions: camelCase (`validateEmail`, `parseConfig`)
- Interface names: often end in `-er` (`Reader`, `Writer`, `Handler`)
- Method receivers: short, consistent names

#### 2. Error Handling Improvements

**Error Wrapping and Context (Golang 1.13+):**
```go
// Good: Error wrapping with context
if err := database.Save(user); err != nil {
    return fmt.Errorf("failed to save user %s: %w", user.ID, err)
}

// Bad: Lost error context
if err := database.Save(user); err != nil {
    return errors.New("database error")
}
```

**Error Handling Patterns:**
- Proper error checking (not ignoring errors with `_`)
- Early returns for error conditions
- Custom error types for better error handling
- Avoiding panic for recoverable errors

#### 3. String and Data Structure Operations

**String Building Performance:**
```go
// Good: Use strings.Builder for concatenation
var builder strings.Builder
builder.Grow(estimatedSize) // Pre-allocate if size known
for _, item := range items {
    builder.WriteString(item)
}
result := builder.String()

// Bad: String concatenation in loops
var result string
for _, item := range items {
    result += item // Creates new string each iteration
}
```

**Slice Operations:**
```go
// Good: Pre-allocate slices when size is known
items := make([]Item, 0, expectedSize)

// Good: Check slice bounds
if len(slice) > 0 {
    first := slice[0]
}

// Good: Efficient slice operations
filtered := items[:0] // Reuse backing array for filtering
for _, item := range items {
    if condition(item) {
        filtered = append(filtered, item)
    }
}
```

#### 4. Constants and Magic Numbers

**Named Constants:**
```go
// Good: Named constants with clear types
const (
    DefaultTimeout = 30 * time.Second
    MaxRetries     = 3
    BufferSize     = 1024

    // Enum-like constants
    StatusPending Status = iota
    StatusApproved
    StatusRejected
)

// Bad: Magic numbers
time.Sleep(30000000000) // What is this duration?
if len(buffer) > 1024 { // Why 1024?
```

#### 5. Function and Method Improvements

**Function Signatures:**
```go
// Good: Context as first parameter
func GetUser(ctx context.Context, id string) (*User, error) {
    // Implementation
}

// Good: Consistent error handling
func ParseConfig(filename string) (*Config, error) {
    if filename == "" {
        return nil, errors.New("filename cannot be empty")
    }
    // Implementation
}

// Bad: Inconsistent patterns
func GetUser(id string, ctx context.Context) (User, error) // Wrong order
func ParseConfig(filename string) *Config // Missing error return
```

**Method Receivers:**
```go
// Good: Consistent receiver names
func (u *User) Validate() error { ... }
func (u *User) Save() error { ... }

// Good: Pointer receivers for modifications
func (u *User) UpdateEmail(email string) error {
    u.Email = email
    return nil
}

// Good: Value receivers for simple accessors
func (u User) FullName() string {
    return u.FirstName + " " + u.LastName
}
```

#### 6. Common Golang Anti-Patterns to Fix

**Goroutine and Channel Issues:**
```go
// Bad: Unbounded goroutines
for _, item := range items {
    go processItem(item) // May create thousands of goroutines
}

// Good: Worker pool pattern
func processItemsConcurrently(items []Item) {
    workers := runtime.NumCPU()
    jobs := make(chan Item, len(items))

    for w := 0; w < workers; w++ {
        go worker(jobs)
    }

    for _, item := range items {
        jobs <- item
    }
    close(jobs)
}
```

**Interface Usage:**
```go
// Bad: Premature interface extraction
type UserService interface {
    CreateUser(User) error
    // Only used once
}

// Good: Use concrete types until interfaces are needed
type UserService struct {
    db Database
}
```

#### 7. Performance Quick Wins

**Map Operations:**
```go
// Good: Pre-allocate maps when size is known
userMap := make(map[string]User, expectedSize)

// Good: Use map for O(1) lookups instead of slice iteration
users := make(map[string]User)
for _, user := range userList {
    users[user.ID] = user
}

if user, exists := users[targetID]; exists {
    // Found in O(1)
}
```

**Memory Allocation:**
```go
// Good: Reuse slices to reduce allocations
type Processor struct {
    buffer []byte
}

func (p *Processor) Process(data []byte) []byte {
    if cap(p.buffer) < len(data) {
        p.buffer = make([]byte, len(data))
    }
    p.buffer = p.buffer[:len(data)]
    copy(p.buffer, data)
    return p.buffer
}
```

#### 8. Code Style and Convention Fixes

**Package and Import Organization:**
```go
// Good: Standard import grouping
import (
    // Standard library
    "context"
    "fmt"
    "time"

    // Third-party packages
    "github.com/gin-gonic/gin"
    "github.com/sirupsen/logrus"

    // Local packages
    "myapp/internal/config"
    "myapp/pkg/database"
)
```

**Comment and Documentation:**
```go
// Good: Proper function documentation
// GetUser retrieves a user by ID from the database.
// It returns ErrUserNotFound if the user doesn't exist.
func GetUser(ctx context.Context, id string) (*User, error) {
    // Implementation
}

// Good: Exported type documentation
// User represents a registered user in the system.
type User struct {
    ID    string
    Email string
}
```

---

### 📤 Golang Quick Fixes Output Format

For each issue identified, provide:

## Issue: [Brief description]
**File:** `path/to/file.go`
**Lines:** X-Y
**Priority:** High/Medium/Low
**Type:** [Error Handling/Performance/Style/Idiom/etc.]

**Current Code:**
```go
// Problematic code here
```

**Suggested Fix:**
```go
// Improved code here
```

**Explanation:** Why this change improves the code (performance, readability, correctness, Golang idioms).

**Impact:** Brief explanation of the benefit of fixing this issue.

---

## Summary

Organize fixes by priority:

### High Priority Issues
- Critical errors or bugs
- Performance problems
- Security concerns
- Major Golang convention violations

### Medium Priority Issues
- Code clarity improvements
- Minor performance optimizations
- Style consistency fixes
- Error handling enhancements

### Low Priority Issues
- Documentation improvements
- Variable naming suggestions
- Minor style adjustments
- Optional optimizations

**Focus on providing specific, actionable fixes that follow Golang best practices and can be easily implemented without major refactoring.**