{"id":"f2371811-fea7-41ec-b0df-079859331391","entityType":"agent","slug":"clawhub-psyb0t-goenv","name":"Goenv","canonicalUrl":"https://www.xpersona.co/agent/clawhub-psyb0t-goenv","canonicalPath":"/agent/clawhub-psyb0t-goenv","generatedAt":"2026-10-12T15:34:50.188Z","source":"CLAWHUB","claimStatus":"UNCLAIMED","verificationTier":"NONE","summary":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-11T22:30:28.374Z","emptyReason":null},"description":"Go library that reads the ENV variable and returns \"dev\" only if exactly \"dev\", otherwise \"prod\" with boolean helpers and fail-safe defaults.","descriptionLabel":"Source description","evidenceSummary":"Capability contract not published. No trust telemetry is available yet. 984 downloads reported by the source. Last updated 10/11/2026.","installCommand":"clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:goenv","sourceUrl":"https://clawhub.ai/psyb0t/goenv","homepage":"https://clawhub.ai/psyb0t/skills/goenv","primaryLinks":[{"label":"View on ClawHub","url":"https://clawhub.ai/psyb0t/goenv","kind":"source"},{"label":"Homepage","url":"https://clawhub.ai/psyb0t/skills/goenv","kind":"homepage"}],"safetyScore":84,"overallRank":62,"popularityScore":60,"trustScore":null,"claimedByName":null,"isOwner":false,"seoDescription":"Goenv technical dossier on Xpersona with agent coverage, OPENCLEW support, and live trust metadata."},"coverage":{"evidence":{"source":"public-profile","verified":false,"confidence":"medium","updatedAt":"2026-10-11T22:30:28.374Z","emptyReason":null},"protocols":[{"protocol":"OPENCLEW","label":"OpenClaw","status":"self-declared","notes":"Declared in the public agent profile."}],"capabilities":[],"verifiedCount":0,"selfDeclaredCount":1,"capabilityMatrix":{"rows":[{"key":"OPENCLEW","type":"protocol","support":"unknown","confidenceSource":"profile","notes":"Listed on profile"}],"flattenedTokens":"protocol:OPENCLEW|unknown|profile"}},"adoption":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-11T22:30:28.374Z","emptyReason":null},"stars":null,"forks":null,"downloads":984,"likes":null,"task":null,"library":null,"packageName":null,"latestVersion":"1.0.11","tractionLabel":"984 downloads"},"release":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-11T22:30:28.308Z","emptyReason":null},"lastUpdatedAt":"2026-10-11T22:30:28.374Z","lastCrawledAt":"2026-10-11T22:30:28.308Z","lastIndexedAt":null,"nextCrawlAt":"2026-10-12T22:30:28.308Z","lastVerifiedAt":null,"highlights":[{"version":"1.0.11","createdAt":"2026-10-10T14:38:28.575Z","changelog":"- Removed the file skill-card.md. - No functional or behavior changes to the skill itself.","fileCount":4,"zipByteSize":5169},{"version":"1.0.10","createdAt":"2026-08-08T21:16:20.158Z","changelog":"- Updated documentation in references/setup.md. - Removed outdated skill-card.md file. - No changes to functionality or API; documentation cleanup only. - Behavior, usage, and public interface remain unchanged.","fileCount":4,"zipByteSize":5400},{"version":"1.0.9","createdAt":"2026-08-08T15:32:33.344Z","changelog":"- Removed the skill-card.md file. - No changes to functionality or documentation content.","fileCount":4,"zipByteSize":5414},{"version":"1.0.8","createdAt":"2026-08-01T20:20:04.610Z","changelog":"- Removed the skill-card.md file. - No other changes to functionality or documentation.","fileCount":4,"zipByteSize":5420},{"version":"1.0.7","createdAt":"2026-07-27T23:34:42.419Z","changelog":"- Removed the file skill-card.md. - No changes to functionality or documentation content. - This update is limited to cleanup of repository metadata.","fileCount":4,"zipByteSize":5518},{"version":"1.0.6","createdAt":"2026-07-27T22:58:15.952Z","changelog":"- Removed the file skill-card.md. - No changes to library code or documentation content besides the file removal.","fileCount":4,"zipByteSize":5279},{"version":"1.0.5","createdAt":"2026-07-27T09:33:36.865Z","changelog":"- Removed the file skill-card.md. - No changes to user-facing functionality or documentation content.","fileCount":4,"zipByteSize":5359},{"version":"1.0.4","createdAt":"2026-07-27T07:37:54.371Z","changelog":"- Removed the file skill-card.md. - No changes to functionality or usage. - No new features or bug fixes in this release.","fileCount":4,"zipByteSize":5190}]},"execution":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No published capability contract is available yet."},"installCommand":"clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:goenv","setupComplexity":"low","setupSteps":["Install using `clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:goenv` in an isolated environment before connecting it to live workloads.","No published capability contract is available yet, so validate auth and request/response behavior manually.","Review the upstream CLAWHUB listing at https://clawhub.ai/psyb0t/goenv before using production credentials."],"contract":{"contractStatus":"missing","authModes":[],"requires":[],"forbidden":[],"supportsMcp":false,"supportsA2a":false,"supportsStreaming":false,"inputSchemaRef":null,"outputSchemaRef":null,"dataRegion":null,"contractUpdatedAt":null,"sourceUpdatedAt":null,"freshnessSeconds":null},"invocationGuide":{"preferredApi":{"snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/trust"},"curlExamples":["curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/snapshot\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/contract\"","curl -s \"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/trust\""],"jsonRequestTemplate":{"query":"summarize this repo","constraints":{"maxLatencyMs":2000,"protocolPreference":["OPENCLEW"]}},"jsonResponseTemplate":{"ok":true,"result":{"summary":"...","confidence":0.9},"meta":{"source":"CLAWHUB","generatedAt":"2026-10-12T15:34:50.187Z"}},"retryPolicy":{"maxAttempts":3,"backoffMs":[500,1500,3500],"retryableConditions":["HTTP_429","HTTP_503","NETWORK_TIMEOUT"]}},"endpoints":{"dossierUrl":"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/dossier","snapshotUrl":"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/snapshot","contractUrl":"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/contract","trustUrl":"https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-goenv/trust"}},"reliability":{"evidence":{"source":"runtime-metrics","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No trust, reliability, or runtime telemetry is available."},"trust":{"status":"unavailable","handshakeStatus":"UNKNOWN","verificationFreshnessHours":null,"reputationScore":null,"p95LatencyMs":null,"successRate30d":null,"fallbackRate":null,"attempts30d":null,"trustUpdatedAt":null,"trustConfidence":"unknown","sourceUpdatedAt":null,"freshnessSeconds":null},"decisionGuardrails":{"doNotUseIf":["Contract metadata is missing or unavailable for deterministic execution."],"safeUseWhen":[],"riskFlags":["missing_or_unavailable_contract","trust_data_unavailable","schema_references_missing"],"operationalConfidence":"low"},"executionMetrics":{"observedLatencyMsP50":null,"observedLatencyMsP95":null,"estimatedCostUsd":null,"uptime30d":null,"rateLimitRpm":null,"rateLimitBurst":null,"lastVerifiedAt":null,"verificationSource":null},"runtimeMetrics":{"successRate":null,"avgLatencyMs":null,"avgCostUsd":null,"hallucinationRate":null,"retryRate":null,"disputeRate":null,"p50Latency":null,"p95Latency":null,"lastUpdated":null}},"benchmarks":{"evidence":{"source":"no-benchmark-data","verified":false,"confidence":"low","updatedAt":null,"emptyReason":"No benchmark suites or observed failure patterns are available."},"suites":[],"failurePatterns":[]},"artifacts":{"evidence":{"source":"CLAWHUB","verified":false,"confidence":"medium","updatedAt":"2026-10-11T22:30:28.374Z","emptyReason":null},"readme":"Skill: Goenv\n\nOwner: psyb0t\n\nSummary: Go library that reads the ENV variable and returns \"dev\" only if exactly \"dev\", otherwise \"prod\" with boolean helpers and fail-safe defaults.\n\nTags: latest:1.0.11\n\nVersion history:\n\nv1.0.11 | 2026-10-10T14:38:28.575Z | auto\n\n- Removed the file skill-card.md.\n- No functional or behavior changes to the skill itself.\n\nv1.0.10 | 2026-08-08T21:16:20.158Z | auto\n\n- Updated documentation in references/setup.md.\n- Removed outdated skill-card.md file.\n- No changes to functionality or API; documentation cleanup only.\n- Behavior, usage, and public interface remain unchanged.\n\nv1.0.9 | 2026-08-08T15:32:33.344Z | auto\n\n- Removed the skill-card.md file.\n- No changes to functionality or documentation content.\n\nv1.0.8 | 2026-08-01T20:20:04.610Z | auto\n\n- Removed the skill-card.md file.\n- No other changes to functionality or documentation.\n\nv1.0.7 | 2026-07-27T23:34:42.419Z | auto\n\n- Removed the file skill-card.md.\n- No changes to functionality or documentation content.\n- This update is limited to cleanup of repository metadata.\n\nv1.0.6 | 2026-07-27T22:58:15.952Z | auto\n\n- Removed the file skill-card.md.\n- No changes to library code or documentation content besides the file removal.\n\nv1.0.5 | 2026-07-27T09:33:36.865Z | auto\n\n- Removed the file skill-card.md.\n- No changes to user-facing functionality or documentation content.\n\nv1.0.4 | 2026-07-27T07:37:54.371Z | auto\n\n- Removed the file skill-card.md.\n- No changes to functionality or usage.\n- No new features or bug fixes in this release.\n\nv1.0.3 | 2026-07-26T15:50:56.608Z | auto\n\n- Removed the file `skill-card.md`.  \n- No changes to functionality or documentation in SKILL.md.  \n- No new features or behavioral changes.  \n- Housekeeping update only.\n\nv1.0.2 | 2026-07-26T04:39:10.933Z | auto\n\n- Updates description and documentation to clarify the library’s behavior, intent, and usage.\n- Explicitly outlines supported environments (`dev` and `prod`) and fail-safe “default to prod” logic.\n- Adds detailed sections for security, usage guides, and when to use or avoid the library.\n- Documents exported constants and example usage in Go programs.\n- No changes to runtime behavior or public API.\n\nArchive index:\n\nArchive v1.0.11: 4 files, 5169 bytes\n\nFiles: references/setup.md (3241b), skill-card.md (1729b), SKILL.md (4716b), _meta.json (125b)\n\nFile v1.0.11:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.11:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.11\",\n  \"publishedAt\": 1791643108575\n}\n\nFile v1.0.11:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.26** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions, three constants, and one type. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.11:skill-card.md\n\n## Description:\n\nGuides Go developers in using goenv to distinguish development from production by reading the ENV variable, treating only the exact value dev as development.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[psyb0t](https://clawhub.ai/user/psyb0t)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nGo developers use this skill to add a small prod/dev environment switch to their applications or understand existing goenv calls. It provides installation guidance, examples, and the exact ENV matching behavior.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: An unset or unexpected ENV value selects production behavior instead of development behavior.\n\nMitigation: Confirm the application needs exact ENV=dev matching before adopting the library; test intended environment values.\n\nRisk: Installation adds a third-party Go module to the project.\n\nMitigation: Review the dependency and its version before running go get.\n\n## Reference(s):\n\n- [Goenv setup and reference](references/setup.md)\n- [Goenv library homepage](https://github.com/psyb0t/goenv)\n- [Goenv ClawHub release](https://clawhub.ai/psyb0t/skills/goenv)\n\n## Skill Output:\n\n**Output Type(s):** [Guidance, Code, Shell commands]\n\n**Output Format:** [Markdown with Go and shell examples]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [None]\n\n## Skill Version(s):\n\n1.0.11 (source: ClawHub release metadata)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.\n\nArchive v1.0.10: 4 files, 5400 bytes\n\nFiles: references/setup.md (3241b), skill-card.md (2165b), SKILL.md (4716b), _meta.json (125b)\n\nFile v1.0.10:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.10:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.10\",\n  \"publishedAt\": 1786223780158\n}\n\nFile v1.0.10:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.26** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions, three constants, and one type. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.10:skill-card.md\n\n## Description:\n\nGoenv helps an agent guide Go developers in using a small ENV-based prod/dev switch where only the exact value \"dev\" returns dev and all other values default to prod.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[psyb0t](https://clawhub.ai/user/psyb0t)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nDevelopers and engineers use this skill when adding or reviewing a minimal prod/dev environment switch in Go code. It is most useful for projects that want boolean helpers around ENV with production as the default.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: The install guidance uses an unpinned Go module fetch, which can introduce supply-chain review risk when adding the dependency.\n\nMitigation: Pin github.com/psyb0t/goenv to a reviewed version in go.mod and review go.sum changes before merging.\n\nRisk: The library only recognizes two environments and treats any value other than exact lowercase \"dev\" as prod.\n\nMitigation: Use it only for binary prod/dev branching and choose a fuller configuration library when staging, test, ci, or configurable environment names are required.\n\nRisk: goenv.Type is a string alias and does not provide compile-time enum safety.\n\nMitigation: Treat goenv.Prod and goenv.Dev as convenience constants and validate values explicitly where stronger type guarantees are needed.\n\n## Reference(s):\n\n- [goenv setup and reference](references/setup.md)\n- [Goenv project homepage](https://github.com/psyb0t/goenv)\n\n## Skill Output:\n\n**Output Type(s):** [Guidance, Code, Shell commands, Configuration]\n\n**Output Format:** [Markdown with Go and bash code blocks]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [May propose go get, go build, and go test commands plus small edits to Go source files.]\n\n## Skill Version(s):\n\n1.0.10 (source: server release evidence)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.\n\nArchive v1.0.9: 4 files, 5414 bytes\n\nFiles: references/setup.md (3230b), skill-card.md (2279b), SKILL.md (4716b), _meta.json (124b)\n\nFile v1.0.9:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.9:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.9\",\n  \"publishedAt\": 1786203153344\n}\n\nFile v1.0.9:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.25** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions and three constants. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.9:skill-card.md\n\n## Description:\n\nGoenv helps agents guide developers in adding and using the Go module github.com/psyb0t/goenv, a tiny helper that reads ENV and returns dev only for the exact value \"dev\" and prod for every other value.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[psyb0t](https://clawhub.ai/user/psyb0t)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nDevelopers and engineers use this skill when they want guidance for adding a minimal prod/dev environment switch to a Go project, or when they need to understand goenv's exact ENV matching behavior before branching application behavior.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: Installing the module may fetch an external Go dependency through the configured Go module proxy.\n\nMitigation: Review the dependency version and module source before running go get, as recommended by the security guidance.\n\nRisk: Only ENV=dev is treated as development; unset, misspelled, uppercase, or other values resolve to prod.\n\nMitigation: Set ENV intentionally before process start and verify tests cover the exact prod/dev behavior expected by the application.\n\nRisk: The helper supports only prod and dev and does not provide compile-time enum safety.\n\nMitigation: Use a fuller configuration package when the project needs staging, test, CI, configurable environment variable names, or nominal type safety.\n\n## Reference(s):\n\n- [Goenv setup and reference](references/setup.md)\n- [goenv GitHub repository](https://github.com/psyb0t/goenv)\n- [Goenv ClawHub page](https://clawhub.ai/psyb0t/skills/goenv)\n\n## Skill Output:\n\n**Output Type(s):** [Guidance, Code, Shell commands, Configuration instructions]\n\n**Output Format:** [Markdown with Go and shell code blocks]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [Guidance centers on a Go module import, go get command, ENV configuration, and prod/dev behavior notes.]\n\n## Skill Version(s):\n\n1.0.9 (source: server release metadata)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.\n\nArchive v1.0.8: 4 files, 5420 bytes\n\nFiles: references/setup.md (3230b), skill-card.md (2334b), SKILL.md (4716b), _meta.json (124b)\n\nFile v1.0.8:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.8:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.8\",\n  \"publishedAt\": 1785615604610\n}\n\nFile v1.0.8:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.25** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions and three constants. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.8:skill-card.md\n\n## Description: <br>\nGoenv helps agents guide Go developers in adding and using github.com/psyb0t/goenv, a small library that reads ENV and reports dev only for the exact value \"dev\", defaulting all other values to prod. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[psyb0t](https://clawhub.ai/user/psyb0t) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nDevelopers and engineers use this skill to add a simple prod/dev environment switch to Go applications or to review existing goenv usage and its exact default-to-prod behavior. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: The library reads the hardcoded ENV variable and treats every value except exactly \"dev\" as \"prod\". <br>\nMitigation: Confirm the application wants exact ENV=dev semantics and set ENV deliberately before process launch. <br>\nRisk: The go get step fetches third-party module code through the configured Go module source. <br>\nMitigation: Review the selected module version and source according to the project's dependency policy before adding it. <br>\nRisk: The goenv.Type alias does not provide compile-time enum safety over arbitrary strings. <br>\nMitigation: Use goenv.Get(), goenv.IsProd(), goenv.IsDev(), and the exported constants rather than treating unrelated strings as validated environments. <br>\n\n\n## Reference(s): <br>\n- [Goenv setup and reference](references/setup.md) <br>\n- [Goenv ClawHub page](https://clawhub.ai/psyb0t/skills/goenv) <br>\n- [Goenv project homepage](https://github.com/psyb0t/goenv) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [Guidance, Markdown, Code, Shell commands, Configuration] <br>\n**Output Format:** [Markdown with Go and bash code blocks] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [May include install commands, import examples, environment-variable settings, and notes about prod/dev behavior.] <br>\n\n## Skill Version(s): <br>\n1.0.8 (source: server-resolved release metadata) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v1.0.7: 4 files, 5518 bytes\n\nFiles: references/setup.md (3230b), skill-card.md (2603b), SKILL.md (4716b), _meta.json (124b)\n\nFile v1.0.7:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.7:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.7\",\n  \"publishedAt\": 1785195282419\n}\n\nFile v1.0.7:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.25** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions and three constants. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.7:skill-card.md\n\n## Description: <br>\nGoenv helps agents add or explain a tiny Go prod/dev environment switch around `github.com/psyb0t/goenv`, which reads `ENV` and returns `dev` only for the exact value `dev`, otherwise `prod`. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[psyb0t](https://clawhub.ai/user/psyb0t) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nDevelopers and engineers use this skill when a Go project needs a small dependency-free way to branch behavior between prod and dev, or when an existing project already imports `github.com/psyb0t/goenv` and needs consistent usage guidance. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: The library models only two environments and treats anything other than exact ENV=dev as prod. <br>\nMitigation: Confirm that a two-state prod/dev switch is appropriate before adopting it; use a fuller configuration library when staging, test, CI, or local environments need distinct handling. <br>\nRisk: The skill may add a third-party Go module to the user's project. <br>\nMitigation: Review and pin the module as part of normal dependency management, then run go build and go test after integration. <br>\nRisk: The exported Type is a string alias and does not provide compile-time enum safety. <br>\nMitigation: Use the provided constants consistently or define stricter project-local validation when arbitrary environment strings must be rejected. <br>\nRisk: The artifact notes a Go 1.25 or newer requirement. <br>\nMitigation: Confirm the project toolchain version before installing the dependency. <br>\n\n\n## Reference(s): <br>\n- [goenv setup and reference](references/setup.md) <br>\n- [goenv GitHub project](https://github.com/psyb0t/goenv) <br>\n- [Goenv ClawHub release page](https://clawhub.ai/psyb0t/skills/goenv) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [Guidance, Markdown, Code, Shell commands, Configuration instructions] <br>\n**Output Format:** [Markdown guidance with Go and shell code snippets] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [May propose importing the Go module, setting the ENV variable, and running go get, go build, or go test.] <br>\n\n## Skill Version(s): <br>\n1.0.7 (source: server release evidence) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v1.0.6: 4 files, 5279 bytes\n\nFiles: references/setup.md (3230b), skill-card.md (2019b), SKILL.md (4716b), _meta.json (124b)\n\nFile v1.0.6:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.6:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.6\",\n  \"publishedAt\": 1785193095952\n}\n\nFile v1.0.6:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.25** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions and three constants. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.6:skill-card.md\n\n## Description: <br>\nGoenv helps agents add or explain github.com/psyb0t/goenv, a tiny Go helper that reads ENV and returns dev only when ENV is exactly \"dev\", otherwise prod. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[psyb0t](https://clawhub.ai/user/psyb0t) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nDevelopers and engineers use this skill to add or reason about a minimal prod/dev switch in Go applications, especially when they want fail-safe production defaults and no runtime network or file access. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: Misconfigured environment values are treated as prod unless ENV is exactly \"dev\". <br>\nMitigation: Confirm that a two-state prod/dev switch is intended and set ENV explicitly before process launch. <br>\nRisk: Adding the dependency may edit the user's Go project and fetch the module through the configured Go module proxy. <br>\nMitigation: Review proposed source changes and run go build or go test after installation. <br>\n\n\n## Reference(s): <br>\n- [goenv setup and reference](references/setup.md) <br>\n- [goenv GitHub repository](https://github.com/psyb0t/goenv) <br>\n- [Goenv on ClawHub](https://clawhub.ai/psyb0t/skills/goenv) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [guidance, markdown, code, shell commands, configuration] <br>\n**Output Format:** [Markdown with Go and shell command examples] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [Guidance may include source edits to the user's Go project and go get, go build, or go test commands.] <br>\n\n## Skill Version(s): <br>\n1.0.6 (source: server release metadata) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v1.0.5: 4 files, 5359 bytes\n\nFiles: references/setup.md (3230b), skill-card.md (2184b), SKILL.md (4716b), _meta.json (124b)\n\nFile v1.0.5:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.5:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.5\",\n  \"publishedAt\": 1785144816865\n}\n\nFile v1.0.5:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.25** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions and three constants. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.5:skill-card.md\n\n## Description: <br>\nGoenv guides agents in adding and using a small Go library that reads the ENV variable and reports either dev or prod with production as the default. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[psyb0t](https://clawhub.ai/user/psyb0t) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nDevelopers and engineers use this skill when they want an agent to add or explain a tiny dependency-free prod/dev switch for Go programs. It is most useful for projects that only distinguish lowercase ENV=dev from a production default. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: Projects that need staging, test, CI, or other environment names could collapse those values to prod. <br>\nMitigation: Use Goenv only when exactly two environments are intended, or choose a fuller configuration library for multi-environment behavior. <br>\nRisk: A value such as DEV, development, or a typo is treated as prod because matching is case-sensitive and exact. <br>\nMitigation: Set ENV once before launch and confirm deployment conventions use lowercase dev when development behavior is expected. <br>\n\n\n## Reference(s): <br>\n- [ClawHub Goenv skill page](https://clawhub.ai/psyb0t/skills/goenv) <br>\n- [Goenv setup and reference](artifact/references/setup.md) <br>\n- [Goenv module homepage](https://github.com/psyb0t/goenv) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [Guidance, Markdown, Code, Shell commands, Configuration instructions] <br>\n**Output Format:** [Markdown with Go and bash code examples] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [Agent output should preserve the exact ENV matching behavior: only lowercase dev maps to dev, and all other values map to prod.] <br>\n\n## Skill Version(s): <br>\n1.0.5 (source: server release metadata) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v1.0.4: 4 files, 5190 bytes\n\nFiles: references/setup.md (3230b), skill-card.md (1822b), SKILL.md (4716b), _meta.json (124b)\n\nFile v1.0.4:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.4:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.4\",\n  \"publishedAt\": 1785137874371\n}\n\nFile v1.0.4:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.25** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions and three constants. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.4:skill-card.md\n\n## Description: <br>\nGoenv helps agents guide Go developers in using github.com/psyb0t/goenv, a small library that reads ENV and returns dev only for the exact value \"dev\" and prod otherwise. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[psyb0t](https://clawhub.ai/user/psyb0t) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nDevelopers and engineers use this skill when adding or reviewing a tiny dependency-free prod/dev switch in a Go program. It provides setup guidance, API examples, behavior tables, and cautions for goenv's exact ENV matching behavior. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: Review before execution as proposals could introduce incorrect or misleading guidance into skills. <br>\nMitigation: Review and scan skill before deployment. <br>\n\n## Reference(s): <br>\n- [Goenv setup and reference](references/setup.md) <br>\n- [Goenv ClawHub listing](https://clawhub.ai/psyb0t/skills/goenv) <br>\n- [goenv package homepage](https://github.com/psyb0t/goenv) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [guidance, markdown, code, shell commands, configuration] <br>\n**Output Format:** [Markdown with Go and shell code blocks] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [Guidance is scoped to adding and using the Go module, including ENV behavior, import examples, and build or test commands.] <br>\n\n## Skill Version(s): <br>\n1.0.4 (source: server release evidence) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v1.0.3: 4 files, 5277 bytes\n\nFiles: references/setup.md (3230b), skill-card.md (2019b), SKILL.md (4716b), _meta.json (124b)\n\nFile v1.0.3:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.3:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.3\",\n  \"publishedAt\": 1785081056608\n}\n\nFile v1.0.3:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.25** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions and three constants. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.3:skill-card.md\n\n## Description: <br>\nGoenv guides agents in helping Go developers install and use the github.com/psyb0t/goenv library, a two-state ENV-based prod/dev helper with default-to-prod behavior. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[psyb0t](https://clawhub.ai/user/psyb0t) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nDevelopers and engineers use this skill to add or review a small prod/dev switch in Go applications, including install commands, import examples, and ENV behavior checks. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: The ENV switch only distinguishes exact lowercase dev from prod, so staging, test, empty, or mistyped values resolve to prod. <br>\nMitigation: Confirm that a two-state dev/prod model and default-to-prod behavior match the application's deployment semantics before adopting it. <br>\nRisk: The skill guides installation of a third-party Go module. <br>\nMitigation: Review and pin the module as part of normal dependency intake before use in production code. <br>\n\n\n## Reference(s): <br>\n- [Goenv ClawHub skill page](https://clawhub.ai/psyb0t/skills/goenv) <br>\n- [goenv repository homepage](https://github.com/psyb0t/goenv) <br>\n- [setup & reference](references/setup.md) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [guidance, markdown, code, shell commands, configuration] <br>\n**Output Format:** [Markdown with Go and shell snippets] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [Focuses on the ENV variable, Go toolchain usage, and the library's exact dev/prod behavior.] <br>\n\n## Skill Version(s): <br>\n1.0.3 (source: server release evidence) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>\n\nArchive v1.0.2: 4 files, 5419 bytes\n\nFiles: references/setup.md (3230b), skill-card.md (2326b), SKILL.md (4716b), _meta.json (124b)\n\nFile v1.0.2:SKILL.md\n\n---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to prod\" semantics without writing the switch yourself.\n\n## When NOT to use\n\n- You need **more than two environments** (staging, test, ci, local, …) — goenv only knows `dev` and `prod`; everything that isn't exactly `\"dev\"` collapses to `prod`.\n- You need to read env vars **other than `ENV`**, or a configurable variable name — goenv reads the hardcoded `ENV` and nothing else. Reach for a real config library (e.g. `gonfiguration`) for anything richer.\n- You expect **compile-time type safety** from the `Type` type — it's a `string` alias, so `goenv.Type` *is* `string`; the constants are conveniences, not an enum, and any string is assignable. If you need a distinct nominal type, this isn't it.\n\n## Usage\n\n```go\nimport \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\"\n```\n\nThe mapping is exact: `Get()` returns `Dev` only when `ENV` is precisely `\"dev\"`; every other value — unset, empty, `\"DEV\"`, `\"development\"`, `\"prod\"`, or anything else — returns `Prod`. Set it before your process starts:\n\n```bash\nENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)\n```\n\nFor the module path, supported Go version, and the full behavior table, see [references/setup.md](references/setup.md).\n\nFile v1.0.2:_meta.json\n\n{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.2\",\n  \"publishedAt\": 1785040750933\n}\n\nFile v1.0.2:references/setup.md\n\n# goenv — setup & reference\n\n## Requirements\n\n- Go **1.25** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions and three constants. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for override).\n- **No type safety.** Because `Type` is a `string` alias, the compiler won't stop you assigning an arbitrary string where a `goenv.Type` is expected. Treat `Prod`/`Dev` as convenient constants, not a closed enum.\n\nFile v1.0.2:skill-card.md\n\n## Description: <br>\nGoenv helps agents guide Go developers through installing and using `github.com/psyb0t/goenv`, a small library that reads the `ENV` variable and returns `dev` only for the exact value `dev`, otherwise defaulting to `prod`. <br>\n\nThis skill is ready for commercial/non-commercial use. <br>\n\n## Publisher: <br>\n[psyb0t](https://clawhub.ai/user/psyb0t) <br>\n\n### License/Terms of Use: <br>\nMIT-0 <br>\n\n\n## Use Case: <br>\nDevelopers and engineers use this skill when they want concise guidance for adding a dependency-free prod/dev switch to a Go project or for reading an existing `goenv` integration consistently. It is best suited for projects that intentionally use a hardcoded `ENV` variable and accept default-to-prod behavior. <br>\n\n### Deployment Geography for Use: <br>\nGlobal <br>\n\n## Known Risks and Mitigations: <br>\nRisk: Projects that do not intend to use a hardcoded ENV variable may get misleading environment decisions. <br>\nMitigation: Confirm the project wants ENV as the environment selector before installing or applying the guidance. <br>\nRisk: Unset, empty, misspelled, or non-dev ENV values resolve to prod, which can surprise users expecting staging, test, CI, or local modes. <br>\nMitigation: Document the two-environment behavior clearly and use a fuller configuration library when more than dev and prod are required. <br>\n\n\n## Reference(s): <br>\n- [Goenv setup and reference](references/setup.md) <br>\n- [goenv GitHub repository](https://github.com/psyb0t/goenv) <br>\n- [Goenv on ClawHub](https://clawhub.ai/psyb0t/skills/goenv) <br>\n\n\n## Skill Output: <br>\n**Output Type(s):** [guidance, markdown, code, shell commands, configuration] <br>\n**Output Format:** [Markdown with Go and bash code blocks] <br>\n**Output Parameters:** [1D] <br>\n**Other Properties Related to Output:** [May propose edits to project Go source files and Go toolchain commands; the referenced library reads only the ENV environment variable at runtime.] <br>\n\n## Skill Version(s): <br>\n1.0.2 (source: server release metadata) <br>\n\n## Ethical Considerations: <br>\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment. <br>","readmeExcerpt":"Skill: Goenv Owner: psyb0t Summary: Go library that reads the ENV variable and returns \"dev\" only if exactly \"dev\", otherwise \"prod\" with boolean helpers and fail-safe defaults. Tags: latest:1.0.11 Version history: v1.0.11 | 2026-10-10T14:38:28.575Z | auto - Removed the file skill-card.md. - No functional or behavior changes to the skill itself. v1.0.10 | 2026-08-08T21:16:20.158Z | auto - Updated documentation in ref","codeSnippets":[],"executableExamples":[{"language":"go","snippet":"import \"github.com/psyb0t/goenv\"\n\n// The current environment as a string (\"prod\" or \"dev\"):\nswitch goenv.Get() {\ncase goenv.Dev:\n    // dev-only behavior\ndefault: // goenv.Prod\n    // prod behavior\n}\n\n// Or the boolean shortcuts:\nif goenv.IsDev() {\n    logger.SetLevel(\"debug\")\n}\nif goenv.IsProd() {\n    enableStrictMode()\n}\n\n// The recognized values and the variable name are exported constants:\n_ = goenv.Prod         // \"prod\"\n_ = goenv.Dev          // \"dev\"\n_ = goenv.EnvVarName   // \"ENV\""},{"language":"bash","snippet":"ENV=dev  ./yourapp     # dev\nENV=prod ./yourapp     # prod\n./yourapp              # ENV unset → prod (the default)"},{"language":"bash","snippet":"go get github.com/psyb0t/goenv"},{"language":"go","snippet":"import \"github.com/psyb0t/goenv\""},{"language":"go","snippet":"package main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}"},{"language":"bash","snippet":"ENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)"}],"parameters":null,"dependencies":[],"permissions":[],"extractedFiles":[{"path":"SKILL.md","content":"---\nname: goenv\ndescription: Go library that reads one environment variable and tells you if you're in prod or dev. `github.com/psyb0t/goenv` wraps `os.Getenv(\"ENV\")` behind three calls — `goenv.Get()` returns the current env as a string (`\"prod\"` or `\"dev\"`), `goenv.IsProd()` and `goenv.IsDev()` return bools. It recognizes exactly two environments: `dev` when `ENV` is precisely `\"dev\"`, and `prod` for everything else (unset, empty, `\"production\"`, `\"DEV\"`, anything) — a fail-safe default to prod. Exposes constants `goenv.Prod`/`goenv.Dev` and the env-var name as `goenv.EnvVarName`. Zero dependencies beyond the stdlib `os`; no network, no files, no config. Note `Type` is a string *alias*, so it gives no compile-time safety over a bare `string`. Use when the user wants a tiny dependency-free prod/dev switch in a Go program, or is already importing goenv and wants to branch behavior on the environment.\nhomepage: https://github.com/psyb0t/goenv\nuser-invocable: true\nmetadata:\n  openclaw:\n    emoji: \"🌍\"\n    primaryEnv: ENV\n    requires:\n      bins:\n        - go\npermissions:\n  filesystem: \"Guides adding one import and a few calls to your project's own Go source — edits `.go` files in the current project only. The library itself writes nothing.\"\n  shell: \"The Go toolchain (`go get` / `go build` / `go test`) to add and compile the dependency. No other host access.\"\n  network: \"`go get` fetches the module from your configured Go module proxy the first time. The library makes no network calls at runtime.\"\n---\n\n# goenv\n\nA Go library that reads a single environment variable — `ENV` — and answers one question: are you in `prod` or `dev`? That's the whole package. `os.Getenv(\"ENV\")` with a fail-safe default and three named helpers, zero dependencies. Import it and call `goenv.Get()`.\n\nFor install, the exact match/default behavior, and a worked example, see [references/setup.md](references/setup.md).\n\n## Security & safety\n\n- **It reads exactly one environment variable — `ENV` — and nothing else.** No other env vars are read, nothing is written to disk, no network calls are made at runtime, and no data leaves your process. Its only import is the stdlib `os`.\n- **It's a library you compile into your own binary** — it has no runtime surface of its own. Whatever your program does with the prod/dev answer is on you, same as any code you'd write by hand.\n- **Fail-safe by design:** an unrecognized or unset `ENV` resolves to `prod`, so a misconfigured environment errs toward production-grade behavior rather than accidentally enabling dev-only shortcuts.\n\n## When to use\n\n- A Go program needs a small, dependency-free way to branch behavior between two environments (prod vs dev) — e.g. verbose logging in dev, stricter defaults in prod.\n- The project already imports `github.com/psyb0t/goenv` and you want to add or read a prod/dev check consistently (`goenv.IsProd()` / `goenv.IsDev()` instead of hand-rolled `os.Getenv` comparisons).\n- You want the fail-safe \"default to pro"},{"path":"_meta.json","content":"{\n  \"ownerId\": \"kn79dhvmpjng4rp2jjk8k0v5xx80ccbk\",\n  \"slug\": \"goenv\",\n  \"version\": \"1.0.11\",\n  \"publishedAt\": 1791643108575\n}"},{"path":"references/setup.md","content":"# goenv — setup & reference\n\n## Requirements\n\n- Go **1.26** or newer (per the module's `go.mod`).\n- Nothing else. goenv's only import is the standard library `os`; it pulls in zero third-party dependencies.\n\n## Install\n\n```bash\ngo get github.com/psyb0t/goenv\n```\n\nThen import it in your Go code:\n\n```go\nimport \"github.com/psyb0t/goenv\"\n```\n\nModule path: `github.com/psyb0t/goenv`.\n\n## The entire API\n\nThree functions, three constants, and one type. That's the whole surface.\n\n| Symbol | Kind | Behavior |\n|---|---|---|\n| `goenv.Get() goenv.Type` | func | Returns the current environment: `Dev` if `ENV == \"dev\"` exactly, otherwise `Prod`. |\n| `goenv.IsProd() bool` | func | `Get() == Prod`. True unless `ENV` is exactly `\"dev\"`. |\n| `goenv.IsDev() bool` | func | `Get() == Dev`. True only when `ENV` is exactly `\"dev\"`. |\n| `goenv.Prod` | const | The string `\"prod\"`. |\n| `goenv.Dev` | const | The string `\"dev\"`. |\n| `goenv.EnvVarName` | const | The string `\"ENV\"` — the variable it reads. |\n| `goenv.Type` | type | A **string alias** (`type Type = string`). `goenv.Type` is interchangeable with `string`; the constants above are typed as `Type` but provide no compile-time enum enforcement. |\n\n## Behavior table\n\n`Get()` does a single exact-match `switch` on `os.Getenv(\"ENV\")`:\n\n| `ENV` value | `Get()` | `IsProd()` | `IsDev()` |\n|---|---|---|---|\n| `dev` | `dev` | false | true |\n| `prod` | `prod` | true | false |\n| (unset) | `prod` | true | false |\n| `` (empty) | `prod` | true | false |\n| `DEV` / `Dev` | `prod` | true | false |\n| `development` | `prod` | true | false |\n| anything else | `prod` | true | false |\n\nThe match is **case-sensitive and exact** — only the literal lowercase `\"dev\"` counts as dev. Everything else (including the string `\"prod\"` itself, and any typo) resolves to `Prod`. This is deliberate: an unknown or misconfigured environment fails safe toward production behavior.\n\nEach call re-reads the environment (`os.Getenv`), so if something in your process mutates `ENV` at runtime, subsequent `Get()`/`IsProd()`/`IsDev()` calls reflect the new value. In practice set `ENV` once before launch and leave it.\n\n## Worked example\n\n```go\npackage main\n\nimport (\n\t\"fmt\"\n\n\t\"github.com/psyb0t/goenv\"\n)\n\nfunc main() {\n\tfmt.Printf(\"environment: %s\\n\", goenv.Get())\n\n\tif goenv.IsDev() {\n\t\tfmt.Println(\"dev mode: verbose logging, hot reload, relaxed timeouts\")\n\t\treturn\n\t}\n\n\t// goenv.IsProd() — the default path\n\tfmt.Println(\"prod mode: structured logs, strict timeouts\")\n}\n```\n\n```bash\nENV=dev go run .    # → environment: dev  → dev mode ...\ngo run .            # → environment: prod → prod mode ...  (ENV unset)\n```\n\n## Notes / limitations\n\n- **Two environments only.** There is no `staging`/`test`/`ci` — anything that isn't exactly `\"dev\"` is treated as `prod`. If you need more, this library can't express it; use a fuller config package.\n- **Fixed variable name.** It always reads `ENV`; the name isn't configurable (it's exported as `goenv.EnvVarName` for reference, not for o"},{"path":"skill-card.md","content":"## Description:\n\nGuides Go developers in using goenv to distinguish development from production by reading the ENV variable, treating only the exact value dev as development.\n\nThis skill is ready for commercial/non-commercial use.\n\n## Publisher:\n\n[psyb0t](https://clawhub.ai/user/psyb0t)\n\n### License/Terms of Use:\n\nMIT-0\n\n## Use Case:\n\nGo developers use this skill to add a small prod/dev environment switch to their applications or understand existing goenv calls. It provides installation guidance, examples, and the exact ENV matching behavior.\n\n### Deployment Geography for Use:\n\nGlobal\n\n## Known Risks and Mitigations:\n\nRisk: An unset or unexpected ENV value selects production behavior instead of development behavior.\n\nMitigation: Confirm the application needs exact ENV=dev matching before adopting the library; test intended environment values.\n\nRisk: Installation adds a third-party Go module to the project.\n\nMitigation: Review the dependency and its version before running go get.\n\n## Reference(s):\n\n- [Goenv setup and reference](references/setup.md)\n- [Goenv library homepage](https://github.com/psyb0t/goenv)\n- [Goenv ClawHub release](https://clawhub.ai/psyb0t/skills/goenv)\n\n## Skill Output:\n\n**Output Type(s):** [Guidance, Code, Shell commands]\n\n**Output Format:** [Markdown with Go and shell examples]\n\n**Output Parameters:** [1D]\n\n**Other Properties Related to Output:** [None]\n\n## Skill Version(s):\n\n1.0.11 (source: ClawHub release metadata)\n\n## Ethical Considerations:\n\nUsers should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment."}],"languages":[],"docsSourceLabel":"CLAWHUB","editorialOverview":null,"editorialQuality":{"score":100,"threshold":65,"status":"thin","wordCount":1551,"uniquenessScore":40,"reasons":["uniqueness-below-45"]}},"media":{"evidence":{"source":"no-media","verified":false,"confidence":"low","updatedAt":"2026-10-11T22:30:28.374Z","emptyReason":"No screenshots, media assets, or demo links are available."},"primaryImageUrl":null,"mediaAssetCount":0,"assets":[],"demoUrl":null},"ownerResources":{"evidence":{"source":"unclaimed","verified":false,"confidence":"low","updatedAt":"2026-10-11T22:30:28.374Z","emptyReason":"This page has not been claimed by the agent owner."},"hasCustomPage":false,"customPageUpdatedAt":null,"customLinks":[],"structuredLinks":{"docsUrl":null,"demoUrl":null,"supportUrl":null,"pricingUrl":null,"statusUrl":null},"customPage":null},"relatedAgents":{"evidence":{"source":"protocol-neighbors","verified":false,"confidence":"medium","updatedAt":"2026-10-12T15:34:50.188Z","emptyReason":null},"items":[{"id":"8ebccd8e-3863-4187-8355-c3f14e1f9edf","entityType":"agent","canonicalPath":"/agent/iofficeai-aionui","slug":"iofficeai-aionui","name":"AionUi","description":"Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!","url":"https://github.com/iOfficeAI/AionUi","homepage":"https://www.aionui.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-10-09T19:11:12.944Z","createdAt":"2026-02-25T03:38:16.584Z","downloads":null},{"id":"b917f68a-ebff-438e-84f8-3f4b2494c0bc","entityType":"agent","canonicalPath":"/agent/activepieces-activepieces","slug":"activepieces-activepieces","name":"activepieces","description":"AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents","url":"https://github.com/activepieces/activepieces","homepage":"https://www.activepieces.com","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-15T02:22:12.426Z","createdAt":"2026-02-25T03:38:12.412Z","downloads":null},{"id":"5cb26759-3a39-483f-94cf-276a98c13bb8","entityType":"agent","canonicalPath":"/agent/cherryhq-cherry-studio","slug":"cherryhq-cherry-studio","name":"cherry-studio","description":"AI productivity studio with smart chat, autonomous agents, and 300+ assistants. Unified access to frontier LLMs","url":"https://github.com/CherryHQ/cherry-studio","homepage":"https://cherry-ai.com","source":"GITHUB_REPOS","protocols":["MCP","OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-04-11T14:38:40.986Z","createdAt":"2026-02-25T03:38:19.379Z","downloads":null},{"id":"6f6582d0-5d76-4f0f-b81d-86520247950b","entityType":"agent","canonicalPath":"/agent/copilotkit-copilotkit","slug":"copilotkit-copilotkit","name":"CopilotKit","description":"The Frontend for Agents & Generative UI. React + Angular","url":"https://github.com/CopilotKit/CopilotKit","homepage":"https://docs.copilotkit.ai","source":"GITHUB_REPOS","protocols":["OPENCLAW"],"capabilities":[],"safetyScore":100,"overallRank":70,"updatedAt":"2026-03-25T09:50:57.846Z","createdAt":"2026-02-25T03:39:14.617Z","downloads":null}],"links":{"hub":"/agent","source":"/agent/source/clawhub","protocols":[{"label":"OpenClaw","href":"/agent/protocol/openclew"}]}}}