constellai 0.3.0

package/skills/languages/c/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: c
+description: C is a low-level, statically typed, compiled systems programming language (ISO/IEC 9899, latest C23) used for OS kernels, embedded firmware, and performance-critical code; consult when writing or debugging C, choosing a compiler (gcc/clang), managing pointers, memory, undefined behavior, build flags, or standard-library usage.
+domain: language
+category: language
+tags: [c, c23, gcc, clang, systems, compiled, iso-9899]
+official_sources:
+  - https://en.cppreference.com/w/c
+  - https://www.iso-9899.info/wiki/The_Standard
+  - https://gcc.gnu.org/
+verified: 2026-06-17
+---
+
+# C
+
+## Overview
+C is a small, statically typed, compiled language standardized by ISO/IEC 9899 (current revision C23, published 2024) that maps closely to the machine: manual memory, pointers, and no runtime. It powers operating systems, embedded firmware, language runtimes, and libraries. Read this when writing or debugging C, picking compiler flags, reasoning about undefined behavior, or managing memory and pointers.
+
+## Official sources
+- Docs: https://en.cppreference.com/w/c
+- Repo: https://gcc.gnu.org/git.html (GCC) / https://github.com/llvm/llvm-project (Clang)
+- Install: https://gcc.gnu.org/install/
+
+## Install / setup
+```bash
+# Debian/Ubuntu: install the GNU toolchain, then compile to C23
+sudo apt install build-essential
+gcc -std=c23 -Wall -Wextra -O2 hello.c -o hello
+```
+Toolchain per https://gcc.gnu.org/install/ ; `-std=c23` flag per https://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html
+
+## Core concepts
+- **Pointers** — variables holding memory addresses; foundation for arrays, strings, and indirection.
+- **Manual memory** — `malloc`/`calloc`/`realloc`/`free`; no GC, so leaks and double-frees are caller's responsibility.
+- **Undefined behavior (UB)** — out-of-bounds access, signed overflow, use-after-free; the compiler may assume UB never happens.
+- **Translation units & headers** — `.c` files compiled separately; `.h` headers declare shared interfaces; the preprocessor handles `#include`/`#define`.
+- **Standard library** — `<stdio.h>`, `<stdlib.h>`, `<string.h>`, `<stdint.h>` for fixed-width ints.
+- **`const` / `volatile` / `restrict`** — qualifiers controlling mutability, optimization barriers, and aliasing.
+- **C23 additions** — `bool`/`true`/`false`/`nullptr` keywords, `constexpr`, `typeof`, `[[attributes]]`.
+
+## Best practices
+- Compile with `-Wall -Wextra` and treat warnings as errors (`-Werror`) (https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html).
+- Use sanitizers during development: `-fsanitize=address,undefined` to catch memory and UB bugs (https://clang.llvm.org/docs/AddressSanitizer.html).
+- Prefer fixed-width types from `<stdint.h>` (`int32_t`, `size_t`) over assuming `int` width (https://en.cppreference.com/w/c/types/integer).
+- Always check return values of `malloc`, `fopen`, and I/O calls; free every allocation exactly once.
+
+## Common pitfalls
+- Reading/writing past array bounds → use ASan and validate indices; never rely on UB.
+- Forgetting to null-terminate strings or off-by-one in buffer sizes → use `snprintf` and size the buffer for the terminator.
+- Returning a pointer to a stack local → allocate on the heap or pass a caller-owned buffer.
+
+## Examples
+```c
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void) {
+    int *xs = malloc(3 * sizeof *xs);
+    if (!xs) return EXIT_FAILURE;
+    for (int i = 0; i < 3; i++) xs[i] = i * i;
+    for (int i = 0; i < 3; i++) printf("%d\n", xs[i]);
+    free(xs);
+    return EXIT_SUCCESS;
+}
+```
+
+## Further reading
+- https://en.cppreference.com/w/c — community C standard-library and language reference
+- https://gcc.gnu.org/onlinedocs/gcc/ — GCC command and option documentation
+- https://www.iso-9899.info/wiki/The_Standard — index of C standard editions and public working drafts
+
+## Related skills
+- ../objectivec — Objective-C is a strict superset of C with Smalltalk-style messaging
+- ../lua — Lua is implemented in pure ISO C and embeds via the C API

package/skills/languages/clojure/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: clojure
+description: Clojure is a dynamic, functional Lisp dialect on the JVM with immutable persistent data structures and strong concurrency support; consult when writing Clojure, using the Clojure CLI/deps.edn or Leiningen, working with the REPL, transducers, atoms/refs/agents, or interop with Java and ClojureScript.
+domain: language
+category: language
+tags: [clojure, lisp, jvm, functional, repl, deps-edn, clojurescript]
+official_sources:
+  - https://clojure.org/
+  - https://github.com/clojure/clojure
+  - https://clojure.org/guides/install_clojure
+verified: 2026-06-17
+---
+
+# Clojure
+
+## Overview
+Clojure is a dynamic, functional Lisp that compiles to JVM bytecode (with ClojureScript targeting JavaScript), built around immutable persistent data structures and a REPL-driven workflow. It emphasizes pure functions, explicit state, and easy Java interop. Read this when writing Clojure, setting up the CLI/deps.edn, using the REPL, or reasoning about its concurrency primitives.
+
+## Official sources
+- Docs: https://clojure.org/
+- Repo: https://github.com/clojure/clojure
+- Install: https://clojure.org/guides/install_clojure
+
+## Install / setup
+```bash
+# macOS (Homebrew); Java 11+ required
+brew install clojure/tools/clojure
+clj  # start a REPL
+```
+Command per https://clojure.org/guides/install_clojure (Linux uses the `linux-install.sh` script from the same page).
+
+## Core concepts
+- **Immutable persistent data structures** — lists, vectors, maps, sets are values; "updates" return new structures via structural sharing.
+- **REPL-driven development** — evaluate forms interactively against a running program; the core of the Clojure workflow.
+- **Homoiconicity & macros** — code is data (s-expressions); `defmacro` transforms forms at compile time.
+- **deps.edn & the CLI** — `clj`/`clojure` resolve dependencies from `deps.edn`; tools.deps is the official build/run mechanism.
+- **Sequences & laziness** — the `seq` abstraction plus lazy sequences over collections; `map`/`filter`/`reduce` are universal.
+- **Concurrency primitives** — `atom` (uncoordinated sync state), `ref`+`dosync` (STM), `agent` (async), `volatile`.
+- **Java interop** — call any Java via `(.method obj)`, `(Class/staticMethod)`, and `(new Class)` / `Class.`.
+- **Transducers** — composable, source-independent transformations decoupled from input/output collections.
+
+## Best practices
+- Drive development from the REPL; reload changed namespaces rather than restarting (https://clojure.org/guides/repl/introduction).
+- Prefer pure functions on immutable data; isolate state in `atom`/`ref` and mutate explicitly (https://clojure.org/reference/atoms).
+- Use `deps.edn` aliases for tasks (test, build, run) instead of ad-hoc scripts (https://clojure.org/guides/deps_and_cli).
+- Add type/shape checks with `clojure.spec` at boundaries (https://clojure.org/guides/spec).
+
+## Common pitfalls
+- Holding the head of a large lazy seq → memory blowup; consume eagerly with `doall`/`reduce` or avoid retaining the binding.
+- Expecting side effects inside lazy `map` to run → use `doseq`/`run!` for effects, not lazy sequences.
+- Confusing `=` (value equality) with `identical?` (reference) on immutable values → use `=`.
+
+## Examples
+```clojure
+(defn word-freq [text]
+  (->> (re-seq #"\w+" text)
+       (map clojure.string/lower-case)
+       (frequencies)
+       (sort-by val >)))
+
+(word-freq "the cat the dog the cat")
+;; => ([\"the\" 3] [\"cat\" 2] [\"dog\" 1])
+```
+
+## Further reading
+- https://clojure.org/reference/documentation — official language reference index
+- https://clojuredocs.org/ — community examples for core functions
+- https://clojure.org/guides/deps_and_cli — deps.edn and CLI guide
+
+## Related skills
+- ../haskell — another functional language emphasizing immutability and pure functions
+- ../erlang — shares a focus on concurrency and the actor/process model
+- ../lua — fellow dynamically typed embeddable language

package/skills/languages/cpp/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: cpp
+description: High-performance, statically typed systems language with zero-overhead abstractions; consult for C++ syntax, RAII, and setup.
+domain: language
+category: language
+tags: [cpp, systems, performance, native, compiled]
+official_sources:
+  - https://en.cppreference.com/
+  - https://github.com/cplusplus/draft
+verified: 2026-06-16
+---
+
+# C++
+
+## Overview
+C++ is a statically typed, compiled systems programming language offering low-level control and high performance alongside high-level abstractions (classes, templates, the standard library) with a zero-overhead philosophy. It is standardized by ISO/IEC JTC1/SC22/WG21, with C++23 the most recent published standard and C++26 in progress. Read this when writing performance-critical native code, managing manual resources, or setting up a C++ toolchain.
+
+## Official sources
+- Docs (community reference): https://en.cppreference.com/
+- Repo (standard draft sources): https://github.com/cplusplus/draft
+- Get started: https://isocpp.org/get-started
+
+## Install / setup
+C++ has no single installer; you install a compiler. The official ISO C++ "Get Started" page lists free compilers including GCC (`g++`), Clang, and Visual C++ Community. Typical install of GCC on Debian/Ubuntu:
+
+```bash
+sudo apt install g++
+```
+
+Source / recommended compilers: https://isocpp.org/get-started
+
+## Core concepts
+- RAII (Resource Acquisition Is Initialization) — tie resource lifetime to object scope so destructors release resources deterministically.
+- Value semantics and the rule of move — objects are copied by default; move semantics (`std::move`, move constructors) transfer ownership efficiently.
+- Templates and generic programming — compile-time polymorphism over types; the STL (containers, algorithms, iterators) is built on them.
+- Smart pointers — `std::unique_ptr` and `std::shared_ptr` express ownership and automate deallocation, replacing raw `new`/`delete`.
+- The standard library — containers (`vector`, `map`), algorithms, strings, and ranges (cppreference is the canonical reference).
+- Undefined behavior — the standard leaves some operations (out-of-bounds access, signed overflow, use-after-free) with no defined meaning.
+
+## Best practices
+- Prefer RAII and smart pointers over manual `new`/`delete` to avoid leaks and double-frees (per the C++ Core Guidelines, linked from isocpp.org).
+- Use standard-library containers and algorithms instead of hand-rolled loops and C arrays.
+- Pass large objects by `const&`; use move semantics to avoid needless copies.
+- Compile with warnings on (`-Wall -Wextra`) and target a recent standard (e.g. `-std=c++23`).
+
+## Common pitfalls
+- Dangling pointers/references from use-after-free or returning references to locals → use smart pointers and value semantics; this is undefined behavior.
+- Out-of-bounds container/array access → undefined behavior; use bounds-checked access (`.at()`) or `std::span`/ranges where appropriate.
+- Manual memory management with raw `new`/`delete` leaking on early return/exception → use `unique_ptr`/`shared_ptr` and RAII.
+
+## Examples
+```cpp
+#include <memory>
+#include <string>
+#include <iostream>
+
+struct Greeter {
+    std::string greet(const std::string& name) const {
+        return "Hello, " + name;
+    }
+};
+
+int main() {
+    auto g = std::make_unique<Greeter>();   // RAII: freed automatically
+    std::cout << g->greet("ada") << '\n';
+}
+```
+
+## Further reading
+- Language and library reference: https://en.cppreference.com/
+- ISO C++ home and Core Guidelines: https://isocpp.org/get-started
+
+## Related skills
+- ../swift — a memory-safe systems language that interoperates with C/C++
+- ../scala — managed-VM language for contrast with native compilation

package/skills/languages/csharp/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: csharp
+description: Modern .NET object-oriented language compiled by Roslyn; consult for OOP, async/await, LINQ, and the dotnet CLI.
+domain: language
+category: language
+tags: [csharp, dotnet, roslyn, async, linq]
+official_sources:
+  - https://learn.microsoft.com/en-us/dotnet/csharp/
+  - https://github.com/dotnet/roslyn
+  - https://dotnet.microsoft.com/download
+verified: 2026-06-16
+---
+
+# C#
+
+## Overview
+C# is a modern, statically typed, object-oriented language for the .NET platform. It is compiled by Roslyn (the open-source .NET compiler platform, which also exposes rich code-analysis APIs) and runs on the cross-platform .NET runtime. It is used for web (ASP.NET Core), desktop, mobile (MAUI), cloud, and game development. Read this for OOP fundamentals, async/await, LINQ, and the dotnet CLI.
+
+## Official sources
+- Docs: https://learn.microsoft.com/en-us/dotnet/csharp/
+- Repo (Roslyn compiler): https://github.com/dotnet/roslyn
+- Install / download (.NET SDK): https://dotnet.microsoft.com/download
+
+## Install / setup
+Install the .NET SDK from https://dotnet.microsoft.com/download. Then create and run a console project (per https://learn.microsoft.com/en-us/dotnet/core/tutorials/with-visual-studio-code):
+```bash
+dotnet new console -o HelloWorld
+cd HelloWorld
+dotnet run
+```
+
+## Core concepts
+- Classes, structs, and records: reference types (`class`), value types (`struct`), and `record` types for concise immutable data with value equality.
+- Static typing with type inference: `var` infers the compile-time type; generics provide type-safe collections and APIs.
+- Properties and access modifiers: encapsulate fields with auto-properties; `public`/`private`/`protected`/`internal` control visibility.
+- async/await: the Task-based asynchronous pattern for non-blocking I/O; `async` methods return `Task`/`Task<T>`.
+- LINQ: language-integrated query over collections and other sources, using query or method syntax.
+- Nullable reference types: opt-in compiler analysis (`string?`) that flags potential null dereferences.
+- Exceptions and `using`: structured error handling via `try`/`catch`/`finally`; `using` disposes `IDisposable` resources deterministically.
+
+## Best practices
+- Enable nullable reference types and address compiler nullability warnings to avoid `NullReferenceException`.
+- Use `async`/`await` for I/O-bound work and avoid blocking on tasks (e.g. `.Result`/`.Wait()`), which can deadlock.
+- Dispose `IDisposable` resources with `using` declarations/statements rather than manual cleanup.
+- Prefer LINQ and immutable `record` types for clear, declarative data handling.
+
+## Common pitfalls
+- Blocking on async code with `.Result` or `.Wait()` → can deadlock and wastes threads; `await` instead, all the way up.
+- Dereferencing null references → enable nullable reference types and handle `null` at boundaries.
+- Forgetting to dispose resources (streams, connections) → use `using` to release them deterministically.
+- Catching `Exception` broadly and swallowing it → catch specific exceptions and let unexpected ones propagate.
+
+## Examples
+```csharp
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+class Program
+{
+    static async Task Main()
+    {
+        using var client = new HttpClient();
+        string body = await client.GetStringAsync("https://example.com");
+        Console.WriteLine(body.Length);
+    }
+}
+```
+
+## Further reading
+- A tour of C#: https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/overview
+- C# language reference: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/
+
+## Related skills
+- ../java — another statically typed, object-oriented, VM-hosted language

package/skills/languages/dart/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: dart
+description: Client-optimized, strongly typed language for building apps on any platform (powers Flutter); consult for syntax and setup.
+domain: language
+category: language
+tags: [dart, flutter, client, cross-platform, null-safety]
+official_sources:
+  - https://dart.dev/guides
+  - https://github.com/dart-lang/sdk
+verified: 2026-06-16
+---
+
+# Dart
+
+## Overview
+Dart is an approachable, portable, and productive language for building high-quality apps on any platform; it is the language behind the Flutter UI toolkit. It is strongly typed with sound null safety and compiles to native machine code (mobile/desktop/backend) or to JavaScript and WebAssembly for the web. Read this when writing Dart, building Flutter apps, or setting up the SDK.
+
+## Official sources
+- Docs: https://dart.dev/guides
+- Repo: https://github.com/dart-lang/sdk
+- Install / download: https://dart.dev/get-dart
+
+## Install / setup
+From the official Get Dart page. macOS via Homebrew, verbatim:
+
+```bash
+brew tap dart-lang/dart
+brew install dart
+```
+
+Windows via Chocolatey, verbatim from the same page:
+
+```powershell
+choco install dart-sdk
+```
+
+Source: https://dart.dev/get-dart (note: the Flutter SDK already includes the full Dart SDK)
+
+## Core concepts
+- Sound null safety — types are non-nullable by default; nullable types use `?`, and the compiler guarantees non-null values are never null at runtime.
+- Strong static typing with inference — `var`/`final`/`const` plus full type inference; `dynamic` opts out when needed.
+- Everything is an object — including numbers and functions; functions are first-class values.
+- Async with Futures and Streams — `async`/`await`, `Future<T>`, and `Stream<T>` model single and multiple asynchronous results.
+- Isolates — concurrency via isolated memory units that communicate by message passing (no shared mutable state).
+- AOT and JIT compilation — JIT with hot reload during development, ahead-of-time native or JS/Wasm for release.
+
+## Best practices
+- Follow Effective Dart (the official style/usage/design guide on dart.dev) for idiomatic code.
+- Embrace sound null safety: prefer non-nullable types and handle nullability explicitly rather than reaching for `!`.
+- Use `final`/`const` for values that don't change; mark compile-time constants `const`.
+- Use the Dart SDK tooling (`dart analyze`, `dart format`, `dart test`) and pub for packages.
+
+## Common pitfalls
+- Overusing the null-assertion operator `!` → throws if the value is null at runtime; prefer null-aware operators (`?.`, `??`) and proper null checks.
+- Assuming shared mutable state across isolates → isolates do not share memory; pass data via messages.
+- Forgetting to `await` a `Future` → the code continues before the async work completes, causing race conditions.
+
+## Examples
+```dart
+class Greeter {
+  final String prefix;
+  const Greeter(this.prefix);
+
+  String greet(String? name) =>
+      '$prefix, ${(name == null || name.isEmpty) ? 'world' : name}';
+}
+
+void main() {
+  const g = Greeter('Hello');
+  for (final n in ['ada', 'grace']) {
+    print(g.greet(n));
+  }
+}
+```
+
+## Further reading
+- Language and library guides: https://dart.dev/guides
+- Effective Dart: https://dart.dev/guides (Effective Dart section)
+
+## Related skills
+- ../swift — another client-optimized, null-safe app language
+- ../../stacks — Flutter and Dart web frameworks build on this language

package/skills/languages/elixir/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: elixir
+description: Dynamic, functional language on the BEAM (Erlang VM) for scalable, fault-tolerant apps; consult for syntax, OTP, and setup.
+domain: language
+category: language
+tags: [elixir, functional, beam, erlang, concurrency]
+official_sources:
+  - https://elixir-lang.org/docs.html
+  - https://github.com/elixir-lang/elixir
+verified: 2026-06-16
+---
+
+# Elixir
+
+## Overview
+Elixir is a dynamic, functional language designed for building scalable and maintainable applications, running on the Erlang VM (BEAM) and inheriting its lightweight-process concurrency and fault tolerance. It pairs an approachable Ruby-influenced syntax with OTP's battle-tested distribution and supervision model. Read this when writing Elixir, structuring OTP applications, or setting up the toolchain.
+
+## Official sources
+- Docs: https://elixir-lang.org/docs.html
+- Repo: https://github.com/elixir-lang/elixir
+- Install / download: https://elixir-lang.org/install.html
+
+## Install / setup
+The official install page lists install scripts as the quickest method. Verbatim (Bash):
+
+```bash
+curl -fsSO https://elixir-lang.org/install.sh && sh install.sh elixir@1.20.1 otp@28.4
+```
+
+PowerShell (Windows), verbatim from the same page:
+
+```powershell
+curl.exe -fsSO https://elixir-lang.org/install.bat && .\install.bat elixir@1.20.1 otp@28.4
+```
+
+Source: https://elixir-lang.org/install.html (Homebrew alternative: `brew install elixir`)
+
+## Core concepts
+- Immutability — data is never mutated in place; functions return new transformed values.
+- Pattern matching — the `=` match operator and function-head matching destructure and branch on data shape.
+- The pipe operator `|>` — threads a value through a series of function calls for readable data pipelines.
+- Processes and the actor model — lightweight BEAM processes communicate by message passing, not shared memory.
+- OTP behaviours — GenServer, Supervisor, and Application provide standard patterns for stateful, supervised, fault-tolerant systems.
+- Mix — the build tool for creating projects, running tasks, managing dependencies (Hex), and testing.
+
+## Best practices
+- Embrace the "let it crash" philosophy: supervise processes so failures restart cleanly rather than defensively guarding every error.
+- Use pattern matching in function heads instead of nested conditionals for clear, declarative branching.
+- Structure work into small pure functions and compose them with the pipe operator.
+- Use Mix and the Hex package manager for dependencies and project tasks.
+
+## Common pitfalls
+- Treating BEAM processes like OS threads or assuming shared mutable state → state lives inside a process and is changed only via messages.
+- Overusing `try/rescue` for control flow → prefer pattern matching and supervisors ("let it crash").
+- Blocking a GenServer's single message loop with long synchronous work → offload heavy work to a separate process or Task.
+
+## Examples
+```elixir
+defmodule Greeter do
+  def greet(name), do: "Hello, #{name}"
+end
+
+["ada", "grace"]
+|> Enum.map(&String.capitalize/1)
+|> Enum.each(&IO.puts(Greeter.greet(&1)))
+```
+
+## Further reading
+- Getting started & guides: https://elixir-lang.org/docs.html
+- Installation details and version managers: https://elixir-lang.org/install.html
+
+## Related skills
+- ../ruby — syntactic inspiration for Elixir
+- ../scala — another language emphasizing functional programming on a managed VM

package/skills/languages/erlang/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: erlang
+description: Erlang is a functional, concurrent language built on the BEAM VM and OTP framework for fault-tolerant, distributed, soft-real-time systems using lightweight processes and message passing; consult when writing Erlang, using OTP behaviours (gen_server/supervisor), pattern matching, or building telecom-grade, highly available systems.
+domain: language
+category: language
+tags: [erlang, beam, otp, concurrency, actor-model, distributed, fault-tolerant]
+official_sources:
+  - https://www.erlang.org/docs
+  - https://github.com/erlang/otp
+  - https://www.erlang.org/downloads
+verified: 2026-06-17
+---
+
+# Erlang
+
+## Overview
+Erlang is a functional, concurrent language that runs on the BEAM virtual machine and ships with OTP, a framework for building fault-tolerant, distributed, soft-real-time systems. Concurrency is modeled with cheap isolated processes communicating by asynchronous message passing ("let it crash" with supervision). Read this when writing Erlang, using OTP behaviours like `gen_server` and `supervisor`, or building highly available distributed systems.
+
+## Official sources
+- Docs: https://www.erlang.org/docs
+- Repo: https://github.com/erlang/otp
+- Install: https://www.erlang.org/downloads
+
+## Install / setup
+```bash
+# macOS (Homebrew); or use the installers/source at erlang.org/downloads
+brew install erlang
+erl  # start the Erlang shell
+```
+Install options per https://www.erlang.org/downloads (source build, prebuilt packages, kerl/asdf/mise are all documented there).
+
+## Core concepts
+- **Lightweight processes** — `spawn` creates isolated, scheduler-managed processes (not OS threads); millions can run.
+- **Message passing** — processes communicate with `!` (send) and `receive`; no shared mutable state.
+- **Pattern matching** — bind and destructure in function heads, `case`, and `receive` clauses.
+- **Immutability & single assignment** — variables are bound once; data is immutable.
+- **OTP behaviours** — `gen_server`, `supervisor`, `application`, and `gen_statem` encode proven design patterns.
+- **Supervision trees & "let it crash"** — supervisors restart failed children rather than coding defensive error handling.
+- **Hot code loading** — modules can be upgraded in a running system without downtime.
+- **Distribution** — nodes connect transparently; remote sends look like local sends.
+
+## Best practices
+- Structure systems as supervision trees using OTP behaviours instead of raw `spawn` (https://www.erlang.org/doc/system/design_principles.html).
+- Embrace "let it crash": handle the expected path, let supervisors recover from the unexpected (https://www.erlang.org/doc/system/sup_princ.html).
+- Keep processes small and single-purpose; isolate state per process (https://www.erlang.org/docs).
+- Use `gen_server` for stateful services rather than hand-rolling receive loops (https://www.erlang.org/doc/system/gen_server_concepts.html).
+
+## Common pitfalls
+- Unbounded mailbox growth from selective `receive` not matching messages → match all expected messages and drain/log unexpected ones.
+- Treating processes as cheap shared-memory objects → they have isolated heaps; pass data via messages, copying cost matters for large terms.
+- Blocking a `gen_server` callback with long work → offload to a worker/task process to keep the server responsive.
+
+## Examples
+```erlang
+-module(counter).
+-behaviour(gen_server).
+-export([start_link/0, inc/0, get/0]).
+-export([init/1, handle_call/3, handle_cast/2]).
+
+start_link() -> gen_server:start_link({local, ?MODULE}, ?MODULE, 0, []).
+inc()        -> gen_server:cast(?MODULE, inc).
+get()        -> gen_server:call(?MODULE, get).
+
+init(N)                  -> {ok, N}.
+handle_cast(inc, N)      -> {noreply, N + 1}.
+handle_call(get, _F, N)  -> {reply, N, N}.
+```
+
+## Further reading
+- https://www.erlang.org/docs — official Erlang/OTP documentation hub
+- https://www.erlang.org/doc/system/design_principles.html — OTP design principles
+- https://www.erlang.org/course — getting-started course on erlang.org
+
+## Related skills
+- ../clojure — shares a functional, immutability-first philosophy on a VM
+- ../haskell — another functional language; contrast pure/lazy vs concurrent/eager

package/skills/languages/go/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: go
+description: Compiled, concurrent language for simple, reliable network services; consult for goroutines, modules, and tooling.
+domain: language
+category: language
+tags: [go, golang, concurrency, goroutines, modules]
+official_sources:
+  - https://go.dev/doc/
+  - https://github.com/golang/go
+  - https://go.dev/dl/
+verified: 2026-06-16
+---
+
+# Go
+
+## Overview
+Go is an open-source programming language that makes it easy to build simple, reliable, and efficient software. It is statically typed and compiled, ships with a garbage collector, and provides built-in concurrency primitives (goroutines and channels) designed for network services and tooling. Read this for the module system, concurrency model, and the standard toolchain.
+
+## Official sources
+- Docs: https://go.dev/doc/
+- Repo: https://github.com/golang/go
+- Install / download: https://go.dev/dl/
+
+## Install / setup
+Download the installer for your platform from https://go.dev/dl/ and follow the instructions at https://go.dev/doc/install. Verify the install:
+```bash
+go version
+```
+
+## Core concepts
+- Goroutines and channels: lightweight concurrent functions started with `go`, communicating over typed channels ("share memory by communicating").
+- Modules: dependency management via `go.mod`/`go.sum`; a module is a versioned collection of packages.
+- Interfaces are implicit: a type satisfies an interface simply by implementing its methods — no explicit `implements`.
+- Explicit error handling: functions return `error` values that callers check; no exceptions for ordinary control flow.
+- Structs and methods: data is grouped in structs; methods attach to types via receivers; no class inheritance, composition instead.
+- The standard toolchain: `go build`, `go run`, `go test`, `go fmt`, and `go vet` are part of the official distribution.
+- Defer/panic/recover: `defer` schedules cleanup; `panic`/`recover` are for truly exceptional conditions, not normal errors.
+
+## Best practices
+- Format code with `gofmt`/`go fmt` — canonical formatting is part of the language culture and is non-negotiable in idiomatic Go.
+- Handle every returned `error`; wrap with context using `fmt.Errorf("...: %w", err)` rather than discarding it.
+- Use `context.Context` to carry cancellation and deadlines through call chains, especially for servers.
+- Keep interfaces small and define them at the consumer; prefer composition over inheritance.
+
+## Common pitfalls
+- Ignoring returned errors (`val, _ := ...`) → silently drops failures; check and propagate them.
+- Loop-variable capture in goroutines/closures → in older Go versions the variable was shared; capture explicitly or rely on the per-iteration scoping of recent Go.
+- Unbuffered channel deadlocks → a send blocks until a receiver is ready; ensure a consumer exists or use buffering/`select`.
+- Data races on shared state → guard with channels, `sync.Mutex`, or run `go test -race` to detect them.
+
+## Examples
+```go
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+func main() {
+	var wg sync.WaitGroup
+	results := make(chan int, 3)
+	for i := 1; i <= 3; i++ {
+		wg.Add(1)
+		go func(n int) {
+			defer wg.Done()
+			results <- n * n
+		}(i)
+	}
+	wg.Wait()
+	close(results)
+	for r := range results {
+		fmt.Println(r)
+	}
+}
+```
+
+## Further reading
+- A Tour of Go: https://go.dev/tour/
+- Effective Go: https://go.dev/doc/effective_go
+
+## Related skills
+- (sibling language skills under ../)