backend-go

Enforce hexagonal architecture and layered dependency rules for Go backend development.

1|Updated Feb 16, 2026
One-click install
npx skills add https://github.com/Jeff-Stapleton/dotclaude --skill backend-go-jeff-stapleton
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: backend-go
Source: https://github.com/Jeff-Stapleton/dotclaude/tree/main/.claude/skills/backend-go
Command: npx skills add https://github.com/Jeff-Stapleton/dotclaude --skill backend-go-jeff-stapleton

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a robust framework and enforces best practices for developing the Go backend service, ensuring maintainability, scalability, and adherence to architectural standards.

Core Features & Use Cases

  • Hexagonal Architecture Enforcement: Guides the structure of the Go backend using the Ports and Adapters pattern.
  • Layered Dependency Rules: Ensures imports flow in a controlled direction, preventing tight coupling.
  • Standardized Project Conventions: Defines clear guidelines for directory structure, naming, and patterns.
  • Use Case: When starting a new feature in the operations-back-end service, consult this Skill to understand how to structure your API resolvers, services, and adapters according to established patterns.

Quick Start

Use the backend-go skill to understand the hexagonal architecture patterns for the operations backend service.

Frequently Asked Questions about backend-go

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

FAQPage Schema
How do I structure a Go backend using hexagonal architecture?

Hexagonal architecture in a Go backend structures code using the Ports and Adapters pattern, isolating core logic from external interfaces. It enforces layered dependency rules where imports flow in a controlled direction, preventing tight coupling and ensuring maintainability.

What's the best way to enforce layered dependency rules for Go API development?

Enforcing layered dependency rules in Go API development requires defining clear responsibilities for API, Service, Adapter, and Client layers. Imports must flow in a controlled direction to prevent tight coupling and maintain scalable project conventions.

How do I add GraphQL resolvers for flight operations data in a Go service?

Adding GraphQL resolvers for flight operations data in a Go service involves structuring API resolvers, services, and adapters according to established hexagonal patterns. This facilitates features like load sheets, manifests, and crew operations data retrieval.

Does hexagonal architecture work with existing Go service patterns?

Hexagonal architecture works with Go service patterns by standardizing directory structure, naming conventions, and adapter implementations. It provides a robust framework ensuring maintainability and adherence to architectural standards for operations backend development.

When do I need adapter patterns for Go backend development?

Adapter patterns for Go backend development are needed when integrating external clients or interfaces with core business logic. They define clear responsibilities within the Adapter layer, facilitating features like flight operations data retrieval via GraphQL.