/programming

name: programming
description: "Language-specific patterns and tooling: Go, Kotlin, PHP, Swift, TypeScript."
user-invocable: false
allowed-tools:
  - Read
  - Write
  - Bash
  - Grep
  - Glob
  - Edit
  - Task
  - Skill
routing:
  force_route: true
  not_for: "Python (agents handle directly), general debugging (use debugging). When a dedicated language skill exists (php, swift, kotlin), prefer it over this umbrella"
  triggers:
    # Go
    - .go
    - go test
    - "*_test.go"
    - goroutine
    - sync.Mutex
    - context.Context
    - Go code review
    - Go lint
    - sapcc
    - make check
    # Kotlin
    - "kotlin coroutines"
    - "kotlin Flow"
    - "suspend function"
    - "kotlin testing"
    - kotest
    # PHP
    - "php quality"
    - "php code review"
    - "PSR standards"
    - phpstan
    - phpunit
    # Swift
    - "swift concurrency"
    - "swift async await"
    - "Swift Actor"
    - XCTest
    # TypeScript
    - "TypeScript check"
    - "tsc noEmit"
    - "tsc errors"
  category: language
  pairs_with:
    - golang-general-engineer
    - kotlin-general-engineer
    - php-general-engineer
    - swift-general-engineer
    - typescript-frontend-engineer

Programming

Language-specific patterns and tooling for Go, Kotlin, PHP, Swift, and TypeScript. Identify the language, load matching deep references, follow the language section.

Language Routing

| Language | Agent | Section | |----------|-------|---------| | Go | golang-general-engineer | Go | | Kotlin | kotlin-general-engineer | Kotlin | | PHP | php-general-engineer | PHP | | Swift | swift-general-engineer | Swift | | TypeScript | typescript-frontend-engineer | TypeScript |

If the request spans multiple languages, apply each relevant section.

---

Go

Style Precedence

1. Target repository's explicit rules and compatibility constraints. 2. Google Go Style Guide canonical rules. 3. Google Go Style Decisions normative guidance. 4. Google Go Style Best Practices non-canonical recommendations. 5. Task-specific deep references below.

Prefer local consistency only where the Google guide allows judgment. Do not restyle existing code without cause.

Workflow

1. Classify the task: testing, concurrency, error handling, code review, SAPCC conventions, or quality gate. 2. Load the matching deep reference. 3. Follow the reference's phases, gates, and completion criteria.

For **testing**: table-driven tests with subtests, test helpers, mock injection. Run `go test ./...`. Load `references/go/testing.md`. For **concurrency**: goroutine lifecycle, sync primitives, context propagation, race detection. Run `go test -race`. Load `references/go/concurrency.md`. For **error handling**: wrapping with `%w`, sentinel errors, `errors.Is`/`errors.As`, custom error types. Load `references/go/error-handling.md`. For **code review**: review checklist, common comments, interface compliance. Load `references/go/code-review.md`. For **SAPCC repos**: org conventions -- go-bits patterns, auth ordering, JSON strictness, endpoint identification. Load `references/go/sapcc-conventions.md`. For **quality gate**: run `make check` or equivalent. Load `references/go/quality-gate.md`.

Expert Review Patterns

Beyond linting -- patterns from real code reviews that automated tools miss:

• **Type export design**: keep implementation types unexported; export only interfaces and constructors.
• **Batch+callback races**: `commit()` should remove only the specific batch returned, not all items.
• **Function extraction**: extract only if reused elsewhere or hides complex details.
• **Defer timing**: place `defer f.Close()` after the error check, not before.
• **Go 1.22+ loop variables**: remove `i := i` reassignment and closure parameter passing -- each iteration has its own variable since 1.22.
• **Prometheus metrics**: pre-initialize counters with `.Add(0)` for all known label combinations.
• **Test dedup**: use `testWithEachBackingStore()` pattern to share test bodies across interface implementations.

Scripts

| Task | Script | |------|--------| | Generate table test | `scripts/gen-table-test.sh` | | Benchmark compare | `scripts/bench-compare.sh` | | Check errors | `scripts/check-errors.sh` | | Interface compliance | `scripts/check-interface-compliance.sh` | | SAPCC checks | `scripts/check-sapcc-*.sh` | | Quality checker | `scripts/quality_checker.py`, `scripts/validate.py` | | Google style sync | `scripts/sync-google-style-guide.py` |

---

Kotlin

Core Rules

1. **Structured concurrency is non-negotiable.** Every coroutine must have a parent scope that defines its lifetime. 2. **Inject dispatchers.** Accept `CoroutineDispatcher` as a parameter so callers and tests control threading. 3. **Always rethrow CancellationException.** Catch specific exception types, not broad `Exception`. 4. **Prefer Flow over Channel.** Flow is cold, composable, handles backpressure. Use Channels only for producer-consumer and inter-coroutine communication. 5. **Use supervisorScope for partial failure tolerance.** Independent tasks that should not cancel each other. 6. **No GlobalScope.** Pass a scope from the application framework.

Stream Type Selection

| Type | Temperature | Replay | Use Case | |------|-------------|--------|----------| | `Flow` | Cold | None | Async sequences, API pagination, transform chains | | `StateFlow` | Hot | Latest (1) | UI state with current value; conflates duplicates | | `SharedFlow` | Hot | Configurable | One-shot events: navigation, toasts, errors | | `Channel` | Hot | None | Producer-consumer, fan-in/fan-out inter-coroutine communication |

**Flow**: cold -- each collector gets its own execution. Chain with `filter`, `map`, `flatMapConcat`. Terminate with `collect`. **StateFlow**: requires initial value, always replays latest to new collectors. Use for UI state. **SharedFlow**: configurable replay, emits all values (no conflation). Use for event streams. **Channel**: hot communication primitive. Use `