Skip to content

facta-dev/beautiful-go

v0.1.0MIT

Write, review, port, and enforce idiomatic Go: three skills distilled from Effective Go, the Go Code Review Comments wiki, the Google Go Style Guide, Go Concurrency Patterns, and the facta backend-go handbook, plus a drop-in golangci-lint v2 config with the depguard architecture law.

Beautiful Go

Three standard Agent Skills and a lints config that teach coding agents to write, review, port, and enforce idiomatic Go:

  • go-best-practices loads whenever an agent writes or changes Go, and steers it toward idiomatic, robust, maintainable code — including the architecture contract when your repo follows the facta backend-go stack.
  • go-review reviews existing Go code, a file, a package, a slice, or a diff, and writes a prioritized report where every finding cites the rule it breaks and shows the fix.
  • go-port ports C, C++, Python, JavaScript, TypeScript, Java, or Rust to idiomatic Go with the same behavior, porting the original tests first so you can prove the two match.
  • lints/ is a drop-in golangci-lint v2 configuration whose depguard rules enforce the architecture in CI.

They work with Claude Code, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, and any other agent that reads the Agent Skills format. Every Go example in the skills is syntax-checked in CI, and every depguard rule in the config is proven to fire against the check module in lints/check/.

The guidance is distilled from five sources, with a condensed digest of each bundled in the skill so the agent can consult the original reasoning when it needs to:

Where the sources disagree, the skill picks a side and says which.

Status: first release in progress — see the changelog.

The playbooks

These skills are the runnable, machine-checked enforcement of the facta playbooks. That repository carries the sixteen root playbooks — backend, Java/J2EE, frontend, React Native, Android/Kotlin, iOS/Swift, desktop Qt, CLI, Chrome extension, URLs, tests, security, audit, install, REA and the Claude Code kit — plus the nine runnable kits (Go, Rust, Node.js, Python, Java, extension, desktop, frontend-mobile, mobile-android), the model-routing guide and the instruction-budget tooling. Start with PLAYBOOK_BACKEND.md for this stack, then use this repository as the worked example. The shared contracts (PLAYBOOK_URLS.md, PLAYBOOK_TESTS.md, PLAYBOOK_SECURITY.md, PLAYBOOK_AUDIT.md, PLAYBOOK_CLAUDE_CODE.md) apply across the series.

What it changes

Asked to add an order to a Go backend, an agent without the skill put the pgx import inside domain.go, wrapped the error with %s, and made every test that touches the function depend on a live database. With the skill, the same agent kept the domain I/O-free, declared the port where it is consumed, and pushed pgx into the adapter. Condensed from those two runs:

// Without the skill: domain.go reaches for the database driver, so no test
// can fake it and the use case cannot run without Postgres.
package store

import (
	"context"
	"fmt"

	"github.com/jackc/pgx/v5"
)

type Order struct {
	ID         string
	TotalCents int64
	Status     string
}

// PlaceOrder wraps the driver error with %s and lives next to the model.
func PlaceOrder(ctx context.Context, conn *pgx.Conn, o Order) error {
	_, err := conn.Exec(ctx,
		"insert into orders (id, total_cents, status) values ($1, $2, $3)",
		o.ID, o.TotalCents, o.Status)
	if err != nil {
		return fmt.Errorf("order insert failed: %s", err)
	}
	return nil
}
// With the skill: domain.go holds the order model and a sentinel, and
// nothing else — no net/http, no database/sql, no pgx, no platform.
package store

import "errors"

// ErrInvalidTotal is a sentinel the HTTP adapter can match with errors.Is.
var ErrInvalidTotal = errors.New("order: invalid total")

type Order struct {
	ID         string
	TotalCents int64
	Status     string
}
// ports.go is written by the use case: the consumer defines the port it needs,
// and an interface with no consumer is not written in the first place.
package store

import "context"

// OrderStore is a port; postgres.go satisfies it, tests fake it.
type OrderStore interface {
	SaveOrder(ctx context.Context, o Order) error
}
// usecase.go depends on the port interface, not on postgres.
package store

import (
	"context"
	"fmt"
)

func PlaceOrder(ctx context.Context, s OrderStore, o Order) error {
	if o.TotalCents <= 0 {
		return ErrInvalidTotal
	}
	if err := s.SaveOrder(ctx, o); err != nil {
		return fmt.Errorf("save order %s: %w", o.ID, err)
	}
	return nil
}
// postgres.go is the only file in the slice that knows pgx exists. It calls
// the generated queries, maps rows to the domain type, and translates driver
// errors inward — never inline SQL, which lives in queries.sql.
package store

import (
	"context"
	"fmt"

	"github.com/acme/store-manager/internal/gen/db"
	"github.com/jackc/pgx/v5/pgxpool"
)

type PostgresStore struct {
	pool *pgxpool.Pool
	q    *db.Queries
}

func NewPostgresStore(pool *pgxpool.Pool) *PostgresStore {
	return &PostgresStore{pool: pool, q: db.New(pool)}
}

func (s *PostgresStore) SaveOrder(ctx context.Context, o Order) error {
	if err := s.q.InsertOrder(ctx, db.InsertOrderParams{
		ID:         o.ID,
		TotalCents: o.TotalCents,
		Status:     o.Status,
	}); err != nil {
		return fmt.Errorf("save order %s: %w", o.ID, err)
	}
	return nil
}

The depguard rules in the lints config make the broken shape fail golangci-lint run before it is committed: domain-pure denies github.com/jackc/pgx/v5 in **/internal/features/**/domain.go, and the rest of the law is on the same file. See Enforcing the rules with golangci-lint.

Agent kit (Claude Code)

This repo carries the {kit} kit plane from ai-coding-playbook: .claude/agents, .claude/skills, .claude/commands, and the model-routing:ollama block in CLAUDE.md.

Verify or repair the wiring from the playbook checkout:

bash ai-coding-playbook/scripts/claude-kit/configure-repo.sh . --kit={kit} --check

configure-repo.sh is idempotent, never deletes, and backs up .claude/settings.json under .claude/backups/ before any merge.

Install

Each skill is a folder under skills/: go-best-practices/, go-review/, and go-port/. Every option below puts those folders where your agent looks for skills. Install all three; the review and port skills lean on the best-practices skill for style.

Any agent, one command

The skills installer supports most agents (Node 22.20 or later):

npx skills add Facta-Dev/beautifulgo

Add -g to install for your user instead of the current project, or -a <agent> to pick an agent, such as -a codex or -a cursor.

Claude Code

Install it as a plugin so updates arrive with one command:

claude plugin install beautiful-go --marketplace Facta-Dev/beautifulgo

Inside a session, the same thing is:

/plugin marketplace add Facta-Dev/beautifulgo
/plugin install beautiful-go@beautiful-go

This installs all three skills. They appear as /beautiful-go:go-best-practices, /beautiful-go:go-review, and /beautiful-go:go-port, though you rarely need to call them, since they trigger on their own. To try it for one session without installing, clone the repo and run claude --plugin-dir ./beautifulgo.

OpenAI Codex

Install it as a plugin:

codex plugin marketplace add Facta-Dev/beautifulgo
codex plugin add beautiful-go@beautiful-go

This installs all three skills as beautiful-go:go-best-practices, beautiful-go:go-review, and beautiful-go:go-port. The same package works in the ChatGPT desktop app.

GitHub Copilot

With GitHub CLI 2.90 or later:

gh skill install Facta-Dev/beautifulgo go-best-practices
gh skill install Facta-Dev/beautifulgo go-review
gh skill install Facta-Dev/beautifulgo go-port

This installs into the current project by default. Add --scope user to install for your user, or --agent <name> to install for a different agent.

Gemini CLI

gemini skills install https://github.com/Facta-Dev/beautifulgo --path skills/go-best-practices
gemini skills install https://github.com/Facta-Dev/beautifulgo --path skills/go-review
gemini skills install https://github.com/Facta-Dev/beautifulgo --path skills/go-port

Cursor or anything else: copy the folder

Clone the repo and copy the three skill folders into your agent's skills directory. Most agents now read the shared .agents/skills/ location:

git clone https://github.com/Facta-Dev/beautifulgo
mkdir -p ~/.agents/skills
cp -R beautifulgo/skills/go-* ~/.agents/skills/
AgentUser directoryProject directory
Claude Code~/.claude/skills/.claude/skills/
OpenAI Codex~/.agents/skills/.agents/skills/
GitHub Copilot~/.copilot/skills/ or ~/.agents/skills/.github/skills/ or .agents/skills/
Cursor~/.cursor/skills/ or ~/.agents/skills/.cursor/skills/ or .agents/skills/
Gemini CLI~/.gemini/skills/ or ~/.agents/skills/.gemini/skills/ or .agents/skills/

Claude Code does not read .agents/skills/, so use its own directory or the plugin. Restart the agent if the skill doesn't show up right away.

claude.ai

claude.ai takes one zip per skill, with the skill folder as the zip root:

cd skills
zip -r ../go-best-practices.zip go-best-practices -x '*.DS_Store' -x '*/evals/*'
zip -r ../go-review.zip go-review -x '*.DS_Store' -x '*/evals/*'
zip -r ../go-port.zip go-port -x '*.DS_Store' -x '*/evals/*'

Upload each under Customize > Skills. Code execution must be enabled first.

Reviewing existing code

Ask your agent to review a file, package, slice, or diff, for example "review internal/features/store" or "what would you change in this PR". The go-review skill detects whether the repo is on the facta stack and states which mode it reviewed under, runs gofmt -l, go vet, golangci-lint run, and go test -race when a toolchain is available, then writes a report with three tiers: must fix, should fix, and consider. Every finding gives a file:line location, the rule it breaks with its source (a depguard rule name, a Google Go Style Guide section, a wiki entry, an Effective Go passage, a golangci linter name, or the backend-go handbook), and the smallest code change that fixes it. Each report ends with what the code already does well, so a review never flattens valid idioms to make the report longer.

examples/review-inventory.md is a real review the skill produced for the deliberately messy module in the eval cases.

Porting code to Go

Ask your agent to port a module, for example "port config.c to Go" or "rewrite this Python service in Go". The go-port skill reads the original and its tests, ports the tests first as table-driven Go tests, designs a Go API instead of transliterating the original, and verifies with go test and golangci-lint run. It maps each language's habits to their Go equivalents: NULL and None to nil plus the v, ok := pattern, error codes and exceptions to sentinel errors wrapped with %w, out-parameters to return values, flag ints and magic strings to typed constants, fixed buffers to slices, and dict insertion order to an ordered slice when order is observable, because a map would silently reorder output. Each port comes with a PORTING.md that maps the old API and tests to the new ones and lists every deliberate difference. When the destination is a facta backend-go repo, a port that touches HTTP or storage lands as a vertical slice under the architecture contract.

The stack

The skills enforce the facta backend-go template's stack, restrictively — when a repo has go.mod, internal/features/, and a .golangci.yml with these rules, the writing and review skills read references/backend-go-stack.md first and hold the architecture contract at full strictness. On general Go repos, only the general rules apply: the skills do not impose six-file slices on a CLI.

ConcernThe stack says
Language and moduleGo 1.27, one go.mod per repo, no per-slice modules
Routingchi — REQUIRED, net/http-native (github.com/go-chi/chi/v5); gin/echo acceptable alternatives, fiber only for throughput-critical gateways
Databasepgx/v5 through pgxpool, built once at the composition root
Queriessqlc, per-slice queries.sql → committed internal/gen/db, never hand-edited
Migrationsgolang-migrate, applied as an ops/CI step — never at server startup (goose is the sanctioned alternative)
Loggingslog with the JSON handler, request_id from middleware, never inside domain.go
Lintinggolangci-lint run with the depguard architecture law after gofmt -l and go vet
Authbcrypt + pepper and JWT through the authx platform adapter
JobsRiver durable jobs — same-transaction enqueue, automatic retries, unique and periodic schedules; not goroutines spawned in handlers
DIgoogle/wire, compile-time codegen — no runtime reflection
Validationgo-playground/validator at the transport DTOs (http.go), never in the domain
Cache and realtimego-redis is the mandated cache client — Dragonfly over the Redis protocol (unconditional where the stack runs) — and pgvector for realtime and persistence only where the template's docs define them
ObservabilityOpenTelemetry spans plus Prometheus /metrics
DB poolingPgBouncer in transaction mode in front of pgxpool
DeploymentDocker images, running on Kubernetes

The template's topology is part of the contract, not a suggestion: hexagonal (ports and adapters) plus vertical slicing, dependencies pointing inward (composition root → slices → ports → domain). Each slice is six files — domain.go, ports.go, usecase.go, http.go, postgres.go, module.go — plus its queries.sql; platform/ holds the transversal adapters (config, httpx, pgx, email, realtime, authx); internal/shared/ holds the kernel (apperr, rolex, clockx, idgen). Routes are declared per slice in module.go: Register(r chi.Router, Deps) and composed at cmd/api. Slices never import each other, and the domain imports nothing that does I/O. The stack mandate is deliberately narrow: leave the template's shape alone (a correct six-file slice is already lint-clean) and spend judgment on the code inside it.

What the libraries do and why

Each choice in the stack table exists to hold one boundary of the architecture — the composition root, the slice, the port, or the domain. On a facta backend-go repo the skills treat the whole set as mandated; every reason below traces back to the handbook digest in references/backend-go-stack.md, which the skills read before writing or regenerating anything in a slice.

LibraryWhy this oneWhat it gives the stack
chiThe stack's one sanctioned router, and net/http-native: handlers keep the plain func (w http.ResponseWriter, r *http.Request) signature the stdlib ServeMux had, and chi is excluded from domain-pure's allow-list. Everything else stays stdlib — dependencies cost supply-chain surface.Routes declared per slice in module.go: Register(r chi.Router, Deps), a composable middleware chain (otelhttp → RequestID → Logger → Recover), and /metrics mounted off the same chi tree at the root.
pgx/v5 → pgxpoolThe one Postgres driver; database/sql is denied outright, and pgx/v5 is on the domain-pure deny-list.The pool is built once at the composition root; adapters get narrow store interfaces, never *pgxpool.Pool; driver errors are translated inward at postgres.go.
sqlcQueries compile to type-safe Go instead of living as runtime strings, so a typo fails at generation, not at request time.Per-slice queries.sql → committed internal/gen/db; the postgres.go adapter is the only consumer, gen-check keeps the committed code honest, and hand-editing internal/gen/** is forbidden.
golang-migrateMigrations are a deploy step, never a server-startup concern — under PgBouncer's transaction pooling, schema work cannot ride a pooled connection anyway. (goose is the sanctioned alternative with the same discipline.)Paired Up/Down files in migrations/, paired 1:1 with every queries.sql change (a MUST of the contract), walked apply → down → apply in the integration suite so reversal stays honest.
RiverDurable jobs without hand-rolling the outbox: no outbox tables, no polling loops, no janitor goroutines. The write and its after-effect must commit together — River ships that mechanism instead of leaving teams to invent it.AddTx enqueue inside the same Postgres transaction as the sqlc write, retries with backoff, dedup via UniqueOpts, periodic schedules, and a graceful drain of in-flight jobs on SIGTERM.
go-redisThe mandated cache client — Dragonfly speaks the Redis protocol. Slices never import the client; the same consumer-defined port law as everything else.platform/redis owns the client; slices consume a narrow Cache interface { Get… Set… } port they defined, so unit tests fake it in memory.
google/wireCompile-time DI codegen: wiring is generated, type-checked Go with no runtime reflection and no container to misconfigure.Wiring lives at cmd/api in provider sets — a wiring change is a main.go + provider-set edit, and nothing downstream knows how anything is constructed.
go-playground/validatorInput validation belongs at the trust boundary, applied once at the edge instead of re-argued deep in business code.DTOs validated in http.go at the transport edge; the domain never sees or repeats the validation.
slogStructured logging in the standard library, so the logging dependency is zero and the format is one thing everywhere.The JSON handler with request_id from middleware on every per-request record, logged at the boundary — never inside domain.go, never log-and-return on the same error.
OpenTelemetryREQUIRED, not optional: spans start at otelhttp.NewHandler wrapping the whole server at the chain head.Trace context propagates untouched into use cases and adapters, so adding a span inside a slice touches only that slice.
PrometheusMetrics ride the same chi tree — no second server, no per-slice metrics dependency./metrics mounted off the root; instrumentation state stays in platform/, out of the slices.
PgBouncerTransaction pooling in front of pgxpool keeps connection counts bounded when many slices share one database.The pool is sized for it, prepared statements stay behind the gen/db adapter, and migrations are pushed into the deploy step where they belong.
Docker + KubernetesThe deployment target the topology assumes: images built per service, orchestrated processes that send SIGTERM.The API server and the River worker both drain in-flight work on SIGTERM — a contract that only means something under a scheduler that guarantees the signal.

Enforcing the rules with golangci-lint

The skills teach the rules; the lints keep them from slipping back in. Copy lints/.golangci.yml next to your go.mod, substitute the module path once (internal-package rules must name the real module path, because depguard's pkg patterns prefix-match import paths — pattern plus every subpackage), then run:

sed -i '' 's|github.com/<scope>/<app>|github.com/your/module|g' .golangci.yml
golangci-lint run

On the facta backend-go template this substitution is a no-op before its rename.sh runs: the template's module path is github.com/<scope>/<app> verbatim. The files: globs already use **/internal/... forms, so they match any module without substitution.

It enables the standard linters (errcheck, govet, ineffassign, staticcheck, unused) plus contextcheck, depguard, errname, errorlint, and noctx, and carries the architecture law in four depguard rules:

RuleFilesWhat it enforces
domain-pure**/domain.goan allow-list: the standard library plus internal/shared only — notably denying net/http, chi (github.com/go-chi/chi/v5, prefix-matching its subpackages), database/sql, pgx/v5, internal/gen, internal/platform, and other slices
usecase-transport-free**/usecase.go, **/ports.gonet/http, chi (github.com/go-chi/chi/v5), database/sql, pgx/v5, internal/gen, internal/platform
slice-isolation**/internal/features/**any import from internal/features — slices stay sealed, composition happens in cmd/api
platform-no-features**/internal/platform/**any import from internal/features — platform serves features, never consumes them

Internal-package rules must carry the real module path, because depguard's pkg patterns prefix-match import paths (pattern plus every subpackage, $ for an exact match) — that is why the shipped file carries the github.com/<scope>/<app> placeholder and every other project substitutes its module path once (the one-line sed above). Test files are exempted from errcheck only. errorlint's comparison, assertion, and errorf checks are all on, so %s-wrapped errors, err == sentinel comparisons, and cast-asserted error types all fail the gate.

Every rule in the file is proven to fire. lints/check/ is a throwaway Go module with a clean reference slice (domain, ports, usecase) that must produce zero findings, next to one deliberately violating file per rule, each marked // want <linter>; this script runs the gate on it from the repo root:

bash scripts/check-lints.sh

It fails if a marked violation goes unreported, if something unexpected fires, if the clean slice produces any finding, or if the check module's rule table drifts from lints/.golangci.yml. Requires golangci-lint v2.x on PATH. Stack repos run the full gate in CI: gofmt -l empty, go vet ./..., golangci-lint run, then go test ./... with -race.

What the writing skill covers

skills/go-best-practices/SKILL.md is about 500 lines, organized so an agent can scan it while coding:

  1. Mindset: Go-shaped code, not transliterated Python or Java; zero-I/O domain
  2. Architecture contract: the facta stack's MUST/MUST NOT list, with the lints config as enforcement
  3. Before you hand back code: gofmt -l, go vet, golangci-lint run, go test, gen-check; the nolint policy
  4. Types and interfaces: accept interfaces, return concrete types; no interface pollution; no bool parameters
  5. Errors and panics: sentinels, %w, errors.Is/As; panic only for programmer bugs
  6. Context propagation: ctx first, never stored in structs, never dropped mid-chain
  7. Concurrency: every goroutine has an owner and a shutdown path; channels for ownership, mutexes for state
  8. Standard library first: chi is the stack's one sanctioned router (net/http-native); everything else stays stdlib — dependencies cost supply-chain surface
  9. Packages and file organization: the slice topology wins; no horizontal god-directories
  10. Logging: slog only, JSON handler, structured attrs, never inside domain.go, never log-and-return
  11. Tests: table-driven with named fields, fakes over mocks, t.Parallel, -race
  12. Performance, in order: measure first, preallocate, stream, note deliberate ceilings
  13. Final checklist
  14. References: which digest to open when

skills/go-best-practices/references/ holds one digest per source for deeper lookups.

Layout

beautifulgo/
├── .claude-plugin/
│   ├── plugin.json         Claude Code plugin manifest
│   └── marketplace.json    lets this repo act as its own marketplace
├── .agents/plugins/
│   └── marketplace.json    the same, for Codex
├── plugin.json             Codex and ChatGPT plugin manifest
├── assets/icon.png         plugin icon for Codex and ChatGPT
├── skills/
│   ├── go-best-practices/  writing skill
│   │   ├── SKILL.md
│   │   ├── references/     one digest per source, plus backend-go-stack.md
│   │   └── evals/
│   ├── go-review/          review skill
│   │   ├── SKILL.md
│   │   └── evals/
│   └── go-port/            porting skill
│       ├── SKILL.md
│       └── evals/          a C module and a Python module to port
├── lints/
│   ├── .golangci.yml       the drop-in golangci-lint v2 config
│   ├── README.md           install copy and the rule table
│   └── check/              a Go module: one deliberate violation per rule
├── scripts/
│   ├── check-skill.py      validates skills, evals, and manifests
│   ├── check-lints.sh      proves every depguard rule in the config fires
│   ├── check-examples.py   syntax-checks every Go example in the docs
│   ├── examples.json       context that lets fragment examples parse
│   └── package-openai-plugin.py   builds the ChatGPT / Codex directory ZIP
├── tests/
│   └── test_*.py           unittest suites for the checkers
├── examples/
│   └── review-inventory.md a real review report
├── docs/
│   └── architecture/       rendered HTML diagrams + overview.svg
├── CHANGELOG.md
├── CONTRIBUTING.md
├── PRIVACY.md
└── README.md

Architecture diagrams

The repository ships eight Archify diagrams under docs/architecture/, each a standalone HTML page you can open, explore and share; the overview.svg above is the visual summary.

DiagramWhat it shows
c4-containersClients, ingress, the chi API, the River worker, Postgres, Redis and the mail vendor
services-slicesThe wire composition root, feature slices, platform and adapters, with the depguard walls
auth-algorithmSignup, code, verify and the password-first login gates with rotating refresh
outbox-algorithmRiver's same-transaction enqueue, retries, schedules and the discard path
auth-sequenceThe auth request chain across the slices, Postgres, the worker and the mail vendor
outbox-sequenceThe worker's message trace, ack, backoff and janitor purge
database-dataflowIdentity data, river jobs and the sender
runtime-lifecycleBoot, wire, serve, readyz and the fail-closed endings

Testing the skills

skills/go-best-practices/evals/ holds three test cases in the layout claude plugin eval reads: a stdlib-only rate-limiter library task, a refactor-this-module task with an input file, and a slice-regen task that adds a field and a query to a working six-file slice — the stack-overlay case, which checks the agent upgrades the domain and pairs the query with the migration without touching the six-file shape. Each case has the prompt, a description of a good result, and one assertion per file under graders/, including "does not rewrite existing code" graders. Run them with and without the skill from the skill directory:

claude plugin eval . --allow-tools Write,Edit,Bash --scaffold

skills/go-review/evals/ holds two review cases: one over a slice-shaped module with planted architecture violations and valid shapes that must be left alone, and one over a plain non-stack module (the general-rules mode), each with its planted general-rule violations — and skills/go-port/evals/ holds a C config parser and a Python task graph to port, each with its original test suite. Run them the same way from each skill's directory.

These are real model runs and are billed.

Updating

Edit the skill, bump version in both .claude-plugin/plugin.json and plugin.json (the checker fails if they differ), commit, and push. Claude Code plugin users pick up the new version with:

claude plugin update beautiful-go

Codex users refresh the marketplace with:

codex plugin marketplace upgrade beautiful-go

Anyone who copied the folder or used an installer re-runs the install command. Record each release in CHANGELOG.md.

Validate before pushing. python3 scripts/check-skill.py checks skill frontmatter, links, eval cases, and plugin manifests. Pass --json for machine-readable output. python3 scripts/check-examples.py syntax-checks every Go block in the skills, reference digests, README, and examples with gofmt -e. python3 -m unittest discover tests runs the checker test suites.

python3 scripts/check-skill.py
python3 scripts/check-examples.py
python3 -m unittest discover tests
claude plugin validate .

To publish a release to the ChatGPT / Codex Plugins Directory, update release_notes in plugin.json, then build the upload:

python3 scripts/package-openai-plugin.py

This writes dist/beautiful-go-<version>.zip with the manifest, the skills and their references, the icon, the license, and the privacy policy, but not the eval cases. Upload it at platform.openai.com/plugins from a verified developer account, as described in OpenAI's submission guide.

Contributing

Issues and pull requests are welcome. Every rule needs a published source; see CONTRIBUTING.md for how to propose a rule, report a review false positive, or add an eval case.

Sources and attribution

The guidance in this skill is a synthesis. The five digests in skills/go-best-practices/references/ are paraphrased summaries written for this project; they restate each source's advice in condensed form and link back to the original. Read the originals for the full reasoning.

SourceAuthorLicense
Effective GoThe Go ProjectCC BY 3.0
Go Code Review CommentsThe Go Project (Go wiki)CC BY 3.0
Google Go Style GuideGoogleCC BY 3.0
Go Concurrency PatternsRob PikeCC BY 3.0
the facta backend-go handbookFacta-Devtemplate documentation (the digest in this repo is MIT)

The skill text, the digests, and the config in this repository are MIT licensed (see LICENSE). The icon gopher is our own art, not the official Go logo or mascot.

Siblings

Beautiful Go is part of the Beautiful series for the facta playbooks: beautiful-j2ee, beautifulandroid, beautifulcli, beautifulextension, beautifulios, beautifulnodejs, beautifulpython, beautifulqt, beautifulreact, beautifulreactnative, beautifulrust.

License

MIT. See LICENSE.