Skip to main content Skills Marketplace Découvrez et explorez les compétences IA créées par la communauté.
Métiers associés SOC
Basé sur la classification professionnelle SOC
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Afficher les détails du prompt Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
npx skills add https://github.com/InugamiDev/ultrathink-oss --skill golangLa commande reste sur une seule ligne. Faites défiler horizontalement pour la vérifier avant de la copier.
Vous préférez une copie locale ? Téléchargez les fichiers actuellement disponibles dans SkillsMP.
Télécharger Zip Téléchargement... Plus depuis ce dépôt Unified design foundations — design system architecture, tokens, component specs, visual principles, creative vision, figma integration, plus brand design system loader (66 real brands via DESIGN.md). Absorbs design, design-system, design-systems, design-principles, design-router, creative-vision, figma, design-md.
Render, summarize, and present markdown documents and structured content in multiple output modes
Ultra UI skill - combines Google's DESIGN.md spec (machine-readable design tokens) with the ui-ux-pro-max knowledge base (91 styles, 161 palettes, 73 font pairings, 161 products, 104 UX guidelines, 25 chart types). Generates lint-clean DESIGN.md files, validates token references and WCAG contrast, exports Tailwind/DTCG tokens, and diffs design systems version-over-version.
name golang description Go patterns, concurrency with goroutines/channels, error handling, interfaces, and production-grade service architecture layer domain category backend triggers ["golang","go lang","goroutine","go concurrency","go interface","go error handling"] inputs ["Go application requirements","Concurrency design needs","Service architecture specifications"] outputs ["Idiomatic Go implementations","Concurrency patterns","Production deployment configurations"] linksTo ["microservices","postgresql","redis","message-queues","graphql","websockets"] linkedFrom ["error-handling","logging","testing"] preferredNextSkills ["postgresql","redis","microservices"] fallbackSkills ["rust","nodejs"] riskLevel low memoryReadPolicy selective memoryWritePolicy none sideEffects []
Go Domain Skill
Purpose
Provide expert-level guidance on writing idiomatic Go code, including concurrency patterns with goroutines and channels, error handling, interface design, testing, and production-grade service architecture.
Key Patterns
1. Project Structure
myservice/
├── cmd/
│ └── server/
│ └── main.go # Entry point
├── internal/
│ ├── domain/
│ │ ├── user.go # Domain types
│ │ └── errors.go # Domain errors
│ ├── service/
│ │ ├── user.go # Business logic
│ │ └── user_test.go
│ ├── repository/
│ │ ├── postgres/
│ │ │ └── user.go # Postgres implementation
│ │ └── repository.go # Interface definitions
│ ├── handler/
│ │ ├── user.go # HTTP handlers
│ │ └── middleware.go
│ └── config/
│ └── config.go
├── pkg/ # Reusable packages (if any)
├── migrations/
├── go.mod
├── go.sum
└── Makefile
2. Interface Design
package repository
import "context"
type UserReader interface {
GetUser(ctx context.Context, id string ) (*domain.User, error )
ListUsers(ctx context.Context, opts ListOptions) ([]domain.User, error )
}
type UserWriter interface {
CreateUser(ctx context.Context, u *domain.User) error
UpdateUser(ctx context.Context, u *domain.User) error
DeleteUser(ctx context.Context, id string ) error
}
type UserRepository interface {
UserReader
UserWriter
}
type UserService struct {
repo UserRepository
cache Cache
logger *slog.Logger
}
func NewUserService (repo UserRepository, cache Cache, logger *slog.Logger) return
3. Error Handling package domain
import (
"errors"
"fmt"
)
var (
ErrNotFound = errors.New("not found" )
ErrAlreadyExists = errors.New("already exists" )
ErrUnauthorized = errors.New("unauthorized" )
ErrForbidden = errors.New("forbidden" )
)
type AppError struct {
Code string
Message string
Err error
}
func (e *AppError) string {
if e.Err != nil {
return fmt.Sprintf("%s: %s: %v" , e.Code, e.Message, e.Err)
}
return fmt.Sprintf("%s: %s" , e.Code, e.Message)
}
func (e *AppError) error {
return e.Err
}
func (s *UserService) string ) (*User, error ) {
user, err := s.repo.GetUser(ctx, id)
if err != nil {
if errors.Is(err, ErrNotFound) {
return nil , fmt.Errorf("user %s: %w" , id, err)
}
return nil , fmt.Errorf("getting user %s: %w" , id, err)
}
return user, nil
}
func (h *UserHandler) "id" ))
if err != nil {
switch {
case errors.Is(err, domain.ErrNotFound):
writeError(w, http.StatusNotFound, err.Error())
case errors.Is(err, domain.ErrForbidden):
writeError(w, http.StatusForbidden, "access denied" )
default :
h.logger.Error("unexpected error" , "error" , err)
writeError(w, http.StatusInternalServerError, "internal error" )
}
return
}
writeJSON(w, http.StatusOK, user)
}
4. Concurrency Patterns
func processItems (ctx context.Context, items []Item, workers int ) error ) {
var (
wg sync.WaitGroup
mu sync.Mutex
results = make ([]Result, 0 , len (items))
errs []error
sem = make (chan struct {}, workers)
)
for _, item := range items {
wg.Add(1 )
sem <- struct {}{}
go func (item Item) defer wg.Done()
defer func () defer mu.Unlock()
if err != nil {
errs = append (errs, err)
} else {
results = append (results, result)
}
}(item)
}
wg.Wait()
return results, errors.Join(errs...)
}
import "golang.org/x/sync/errgroup"
func fetchAll (ctx context.Context, urls []string ) error ) {
g, ctx := errgroup.WithContext(ctx)
g.SetLimit(10 )
responses := make ([]Response, len (urls))
for i, url := range urls {
g.Go(func () error {
resp, err := fetch(ctx, url)
if err != nil {
return fmt.Errorf("fetching %s: %w" , url, err)
}
responses[i] = resp
return nil
})
}
if err := g.Wait(); err != nil {
return nil , err
}
return responses, nil
}
func fanOutFanIn (ctx context.Context, input <-chan Job, workers int ) chan Result {
results := make (chan Result)
var wg sync.WaitGroup
for i := 0 ; i < workers; i++ {
wg.Add(1 )
go func () defer wg.Done()
for job := range input {
select {
case <-ctx.Done():
return
case results <- process(job):
}
}
}()
}
go func () close (results)
}()
return results
}
func (s *UserService) error {
if err := s.validate(ctx, u); err != nil {
return err
}
if err := s.repo.CreateUser(ctx, u); err != nil {
return fmt.Errorf("creating user: %w" , err)
}
go func () 30 *time.Second)
defer cancel()
s.sendWelcomeEmail(bgCtx, u)
}()
return nil
}
5. HTTP Server with Graceful Shutdown func main () "postgres" , cfg.DatabaseURL)
if err != nil {
logger.Error("failed to connect to database" , "error" , err)
os.Exit(1 )
}
db.SetMaxOpenConns(cfg.DBMaxConns)
db.SetMaxIdleConns(cfg.DBMaxConns / 2 )
db.SetConnMaxLifetime(30 * time.Minute)
repo := postgres.NewUserRepository(db)
svc := service.NewUserService(repo, logger)
handler := handler.NewRouter(svc, logger)
srv := &http.Server{
Addr: ":" + cfg.Port,
Handler: handler,
ReadTimeout: 15 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
}
go func () "server starting" , "port" , cfg.Port)
if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
logger.Error("server error" , "error" , err)
os.Exit(1 )
}
}()
quit := make (chan os.Signal, 1 )
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
<-quit
logger.Info("shutting down server..." )
ctx, cancel := context.WithTimeout(context.Background(), 30 *time.Second)
defer cancel()
if err := srv.Shutdown(ctx); err != nil {
logger.Error("forced shutdown" , "error" , err)
}
db.Close()
logger.Info("server stopped" )
}
Best Practices
Accept interfaces, return structs -- define interfaces at the call siteAlways propagate context.Context as the first parameterWrap errors with fmt.Errorf("context: %w", err) at every layerUse slog (Go 1.21+) for structured loggingUse errgroup instead of manual sync.WaitGroup + error collectionKeep goroutine lifetimes bounded -- always have a cancellation pathUse go vet, staticcheck, and golangci-lint in CIPrefer table-driven tests with t.Run() subtestsUse internal/ package to prevent external imports of private codeSet GOMAXPROCS appropriately in containerized environments (use automaxprocs)
Common Pitfalls Pitfall Impact Fix Goroutine leak (no cancellation path) Memory/CPU leak Always use context cancellation or done channel Race condition on shared state Data corruption Use sync.Mutex, channels, or sync/atomic Closing a channel from receiver side Panic Only the sender should close channels Ignoring errors (using _) Silent failures Handle or explicitly log every error defer in a loopResource accumulation Extract to a function so defer runs per iteration Using interface{} / any liberally Loses type safety Use generics (Go 1.18+) Not setting HTTP server timeouts Slowloris attacks Always set Read/Write/Idle timeouts
