القائمة
MUST USE for ANY Go (.go) code. Writing, reading, reviewing, refactoring, debugging, testing Go files. Triggers: any .go file, go test, go build, Go module, Go package, Go interface, Go error handling.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
استنادا إلى تصنيف SOC المهني
| name | go-style |
| description | MUST USE for ANY Go (.go) code. Writing, reading, reviewing, refactoring, debugging, testing Go files. Triggers: any .go file, go test, go build, Go module, Go package, Go interface, Go error handling. |
You are writing Go the way I write Go. Follow every rule below. When in doubt,
favour clarity over cleverness, simplicity over abstraction, and explicitness
over magic. When delegating Go work to subagents via task(), always include
"Follow the go-style skill" in the task prompt so the subagent picks it up.
interface{} says nothing (prefer concrete types or small, purpose-built interfaces).This is non-negotiable:
else. Handle the failure/edge case first, then return early.
The happy path hugs the left margin so a reader can follow it with their eyes
in a straight line from top to bottom.// BAD
func process(r *Request) (*Result, error) {
if r.Valid() {
result, err := doWork(r)
if err == nil {
return result, nil
} else {
return nil, fmt.Errorf("doing work: %w", err)
}
} else {
return nil, errors.New("invalid request")
}
}
// GOOD
func process(r *Request) (*Result, error) {
if !r.Valid() {
return nil, errors.New("invalid request")
}
result, err := doWork(r)
if err != nil {
return nil, fmt.Errorf("doing work: %w", err)
}
return result, nil
}
fmt.Errorf("doing X: %w", err).
The wrapping message should describe what the current function was trying to
do, written in lowercase, without a trailing period.errors.New for sentinel errors. Make them constants when possible
(Dave Cheney's "constant errors" pattern).if err != nil { return err }. Add context.Follow Dave Cheney's naming rules:
i, p, r),
single words for parameters and returns, multi-word for package-level names.users not usersMap. count not countInt.ctx not
context for a context.Context).util, base, common,
helpers, or misc.Reader, Stringer), not the thing.internal/ packages
aggressively to hide implementation.func WithTimeout(d time.Duration) Option) for friendly,
extensible APIs.foo uses
package foo_test. This forces you to test through the public API, which:
testdata/ for fixtures. Use testify or standard testing — keep
assertion helpers simple and readable.testing.B, not wall-clock guessing.// Test file for package user lives in package user_test
package user_test
import (
"testing"
"example.com/myapp/user"
)
func TestCreate(t *testing.T) {
// tests go here
}
Avoid these unless you have a very specific, justified reason:
goto and labels – spaghetti code. If you need labeled breaks in nested
loops, restructure your code instead. Labels break glanceability.else – already covered above. Flip the if-condition, return early, keep
the happy path on the left.new() – never use new(T). Always use &T{} for pointer allocation.
The &T{} form is consistent whether you set fields or not, minimising diff
noise when fields are added later.panic – prefer returning errors. The only acceptable panic is replacing a
runtime panic (e.g. nil pointer) with a more descriptive message to help
debugging.Person{"Mat", 42} – what is 42?). Named fields are
self-documenting (Person{Name: "Mat", Age: 42}).http.Handler interface – prefer http.HandlerFunc. Use the closure
pattern: a method on your server struct that returns http.HandlerFunc. This
allows setup/preparation before returning the handler, and middlewares are
just functions wrapping functions.Greeter.Greet(g) instead of g.Greet().
It's obscure syntax that confuses readers.var x []T and append. Optimise capacity later only if benchmarks demand it, and
even then avoid magic capacity numbers — use named constants with comments.defer
error annotation in rare cases.init() functions – they obscure program flow. Pass dependencies
explicitly.database/sql
drivers); always comment why.any / interface{} as lazy API design – if you find yourself reaching
for any, step back and design a proper type or interface.Prefer http.HandlerFunc and the closure pattern for handlers:
// The method lives on your server struct so it has access to dependencies.
// It returns http.HandlerFunc — setup happens before the return.
func (s *server) handleGreet() http.HandlerFunc {
// Preparation runs once at route-registration time (or lazily with sync.Once).
tmpl := template.Must(template.ParseFiles("greet.html"))
return func(w http.ResponseWriter, r *http.Request) {
// Handler logic here — tmpl is captured in the closure.
tmpl.Execute(w, map[string]string{"name": r.URL.Query().Get("name")})
}
}
// For expensive setup, use sync.Once for lazy initialisation:
func (s *server) handleExpensive() http.HandlerFunc {
var (
init sync.Once
tmpl *template.Template
)
return func(w http.ResponseWriter, r *http.Request) {
init.Do(func() {
tmpl = template.Must(template.ParseFiles("expensive.html"))
})
tmpl.Execute(w, nil)
}
}
Middleware is just a function that takes and returns http.HandlerFunc:
func logging(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
log.Printf("%s %s", r.Method, r.URL.Path)
next(w, r)
}
}
Always use &T{} (never new), and always name fields:
// BAD
p := new(Person)
q := Person{"Mat", 42}
// GOOD
p := &Person{}
q := &Person{
Name: "Mat",
Age: 42,
}
The trailing comma after the last field is mandatory (Go enforces this when fields are on separate lines) — it minimises diffs when adding or removing fields.
context.Context for cancellation and deadlines.// Package foo does X. — every exported package gets a doc comment.gofmt everything, always. No exceptions. Use gofumpt if available.go vet and staticcheck. Fix all warnings.