claude-code-go

🥈Silver

Claude Code Go SDK enables developers to integrate Anthropic's Claude Code CLI into Go applications. Operations teams benefit from automated code generation, review, and optimization. It connects to existing Go workflows and tools, enhancing productivity for software development and maintenance tasks.

4050Updated 3w ago

Intermediate30min to implementautomation

Saves ~75 min per use

Quick InstallView Source

git clone https://github.com/lancekrogers/claude-code-go.git

Works with:

Claude

Overview

About This Skill

How to Use

[{"step":"Install the Claude Code Go SDK in your Go project. Run: `go get github.com/anthropics/claude-code-go` and ensure your `CLAUDE_CODE_API_KEY` is set in your environment.","tip":"Use `go mod tidy` to clean up dependencies after installation."},{"step":"Initialize the SDK in your Go code. Example:\n```go\nimport (\n\t\"github.com/anthropics/claude-code-go\"\n)\n\nfunc main() {\n\tclient := claude.NewClient(\"your-api-key\")\n\t// Proceed with SDK operations\n}\n```","tip":"Store your API key securely using environment variables or a secrets manager."},{"step":"Define the task for Claude Code. Use the prompt template to generate a structured request. Example:\n```go\nresponse, err := client.Execute(\"Use the Claude Code Go SDK to optimize the database query in `pkg/db/queries.go`. Focus on reducing query execution time by at least 20% while maintaining correctness.\")\n```","tip":"Break complex tasks into smaller, focused requests to improve accuracy."},{"step":"Process the AI's response. Validate the generated code, run tests, and integrate changes into your workflow. Example:\n```go\nif err := os.WriteFile(\"pkg/db/queries.go\", []byte(response.Code), 0644); err != nil {\n\tlog.Fatal(err)\n}\n```","tip":"Use `go fmt` and `go vet` to ensure the generated code meets Go standards."},{"step":"Iterate as needed. Use the SDK to request additional refinements or reviews. Example:\n```go\nrefinement, _ := client.Execute(\"Review the changes in `pkg/db/queries.go` for potential SQL injection vulnerabilities.\")\n```","tip":"Leverage the SDK's ability to handle multi-turn conversations for iterative improvements."}]

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/lancekrogers/claude-code-go

Requirements

Claude Code or compatible AI agent
Works with: Claude

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Use the Claude Code Go SDK to [TASK] in the [PROJECT_NAME] repository. Focus on [SPECIFIC_GOAL] such as [OPTIMIZATION/REVIEW/GENERATION]. Ensure the changes follow [CODING_STANDARDS] and include unit tests where applicable. Example: 'Use the Claude Code Go SDK to refactor the `pkg/utils` package in the `myapp` repository. Focus on reducing cyclomatic complexity below 10 for all functions. Ensure the changes follow Go conventions and include unit tests for edge cases.'

Example Output

Here’s the refactored `pkg/utils/string_utils.go` file with reduced cyclomatic complexity and added unit tests:

```go
package utils

// Reverse reverses a string while maintaining Unicode correctness.
func Reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

// IsPalindrome checks if a string is a palindrome (case-insensitive).
func IsPalindrome(s string) bool {
	s = strings.ToLower(s)
	for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 {
		if s[i] != s[j] {
			return false
		}
	}
	return true
}
```

**Changes made:**
1. Simplified `Reverse` function by using a single loop and avoiding unnecessary allocations.
2. Refactored `IsPalindrome` to use a single loop and case-insensitive comparison.
3. Added comprehensive unit tests in `pkg/utils/string_utils_test.go`:
   ```go
   func TestReverse(t *testing.T) {
		tests := []struct {
			input    string
			expected string
		}{
			{"hello", "olleh"},
			{"Go", "oG"},
			{"racecar", "racecar"},
			{"🚀🌕", "🌕🚀"}, // Unicode test
		}
		for _, tt := range tests {
			t.Run(tt.input, func(t *testing.T) {
				result := Reverse(tt.input)
				if result != tt.expected {
					t.Errorf("Reverse(%q) = %q, want %q", tt.input, result, tt.expected)
				}
			})
		}
	}
   ```

**Performance impact:**
- Benchmark results show a 30% reduction in memory allocations for `Reverse`.
- `IsPalindrome` now runs in O(n/2) time instead of O(n) with early termination.

**Next steps:**
- Run `go test ./...` to verify all tests pass.
- Merge the changes into the `dev` branch after code review.