go-data-engineer

Implement idiomatic Go ETL pipelines with bounded concurrency and race-safe tests.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/OntoLedgy/ol_ai_context_library --skill go-data-engineer
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: go-data-engineer
Source: https://github.com/OntoLedgy/ol_ai_context_library/tree/main/skills/go-data-engineer
Command: npx skills add https://github.com/OntoLedgy/ol_ai_context_library --skill go-data-engineer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill eliminates the risk of writing non-idiomatic, error-prone Go code for data engineering tasks, extending the base data-engineer role with Go-specific best practices to ensure your pipelines, workers, and services follow Go's core design principles and clean code standards.

Core Features & Use Cases

  • Idiomatic Go Implementation: Build ETL pipelines, streaming workers, CLI tools, and high-throughput services using Go-specific patterns including explicit error returns, implicit interface satisfaction, goroutine/channel concurrency, context propagation, and generics (1.18+).
  • Clean Code Review: Audit existing Go code for compliance with shared clean code standards and Go language best practices.
  • Safe Concurrency Design: Implement bounded, race-safe goroutine and channel patterns including worker pools, fan-in/fan-out, and context propagation for streaming workloads.
  • Use Case: If you are building a real-time transaction processing pipeline in Go, this skill ensures you avoid common pitfalls like unbounded goroutine leaks, improper error wrapping, and non-idiomatic interface usage.

Quick Start

Use the go-data-engineer skill to implement a bounded-concurrency Go ETL pipeline that processes CSV transaction records, applies business logic transformations, and writes results to a PostgreSQL database with proper error wrapping and race-safe unit tests.

Frequently Asked Questions about go-data-engineer

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

FAQPage Schema
How do I build a race-safe ETL pipeline in Go with bounded concurrency?

To build a race-safe ETL pipeline in Go with bounded concurrency, implement worker pools and fan-out/fan-in channel patterns with proper context propagation to prevent goroutine leaks and ensure clean data processing.

What is the best way to handle errors and context propagation in Go data engineering?

The best way to handle errors in Go data engineering is using explicit error returns with proper wrapping, while passing cancellation signals and deadlines through context propagation across all streaming workers and pipeline stages.

Can I use Go generics in high-throughput data pipelines?

Yes, you can use Go generics in high-throughput data pipelines to create type-safe, reusable components for transformations and data processing, ensuring idiomatic structure and strict adherence to Go language standards.

How do I review existing Go code for clean code compliance and idiomatic standards?

Review existing Go code for clean code compliance by auditing for proper interface satisfaction, explicit error handling, and standard project layout, integrating tools like golangci-lint and go test with race detection.

Why does my Go streaming worker leak goroutines during high-throughput processing?

Go streaming workers leak goroutines during high-throughput processing when concurrency is unbounded and context propagation is missing, requiring bounded worker pool patterns and proper channel coordination to resolve.