go

Design Go runtime and kernel components with explicit failure handling.

8|Updated Feb 2, 2026
One-click install
npx skills add https://github.com/usurobor/cnos --skill go-usurobor
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: go
Source: https://github.com/usurobor/cnos/tree/main/src/packages/cnos.eng/skills/eng/go
Command: npx skills add https://github.com/usurobor/cnos --skill go-usurobor

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill guides the design and implementation of Go-based runtime and kernel components for cnos, focusing on clarity, testability, and explicit failure handling.

Core Features & Use Cases

  • Domain-driven package design: build small, cohesive packages with clear boundaries (types, interfaces, errors) to keep the runtime maintainable.
  • Context-aware IO: propagate context through APIs, ensuring cancellable, observable operations at the edge of the kernel and adapters.
  • Observability and testing: use structured logging and table-driven tests to prove both success and degraded paths across runtime surfaces.
  • Use Case: implement a transport adapter or command dispatcher that remains easy to reason about and portable across environments.

Quick Start

Define your first Go subsystem following the Go skill guidance, then run go test ./... to verify.

Frequently Asked Questions about go

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I build Go runtime components that handle errors explicitly?

To build Go runtime components with explicit error handling, enforce explicit domain modeling, clean context propagation, and structured observability. This approach ensures low-level infrastructure remains easy to read and explicit about failure.

What is the best way to propagate context in Go kernel adapters?

The best way to propagate context in Go kernel adapters is through context-aware IO. This ensures cancellable, observable operations at the edge of the kernel and across transport adapters.

How do I structure Go packages for maintainable runtime infrastructure?

Structure Go packages for maintainable runtime infrastructure using domain-driven design. Build small, cohesive packages with clear boundaries for types, interfaces, and errors to keep the kernel maintainable.

Does this approach support structured observability and testing for Go code?

Yes, this approach supports structured observability and testing for Go code. It uses structured logging and table-driven tests to prove both success and degraded paths across runtime surfaces.

Can I use this Go skill to implement a command dispatcher?

Yes, you can use this Go skill to implement a command dispatcher or transport adapter. It ensures the dispatcher remains easy to reason about, portable across environments, and boring to run.