← all publishers

aneviaro

@aneviaro source repo

Report this profile Claim this profile

• 29 skills
• 0 followers
• 9 hours ago last updated

1. ▌
   Learn · aneviaro

   Update project AGENTS.md with strategic knowledge discovered during this session. Defers to project-defined memory-placement guidance when present. Use when the user says "learn", "save knowledge", "update agents.md", "capture learnings", or at the end of significant work sessions.
   0
   installs
2. ▌
   Backlog · aneviaro

   Maintain a project's backlog by adding, updating, or creating docs/backlog.md. Use when the user asks to record a future improvement, backlog item, TODO, or planned enhancement in project documentation.
   0
   installs
3. ▌
   Go Naming · aneviaro bundle

   Use when naming any Go identifier — packages, types, functions, methods, variables, constants, or receivers — to ensure idiomatic, clear names. Also use when a user is creating new types, packages, or exported APIs, even if they don't explicitly ask about naming conventions. Does not cover package organization (see go-packages).
   0
   installs
4. ▌
   Go Context · aneviaro bundle

   Use when working with context.Context in Go — placement in signatures, propagating cancellation and deadlines, and storing values in context vs parameters. Also use when cancelling long-running operations, setting timeouts, or passing request-scoped data, even if they don't mention context.Context directly. Does not cover goroutine lifecycle or sync primitives (see go-concurrency).
   0
   installs
5. ▌
   Go Linting · aneviaro bundle

   Use when setting up linting for a Go project, configuring golangci-lint, or adding Go checks to a CI/CD pipeline. Also use when starting a new Go project and deciding which linters to enable, even if the user only asks about "code quality" or "static analysis" without mentioning specific linter names. Does not cover code review process (see go-code-review).
   0
   installs
6. ▌
   Go Logging · aneviaro bundle

   Use when choosing a logging approach, configuring slog, writing structured log statements, or deciding log levels in Go. Also use when setting up production logging, adding request-scoped context to logs, or migrating from log to slog, even if the user doesn't explicitly mention logging. Does not cover error handling strategy (see go-error-handling).
   0
   installs
7. ▌
   Go Testing · aneviaro bundle

   Use when writing, reviewing, or improving Go test code — including table-driven tests, subtests, parallel tests, test helpers, test doubles, and assertions with cmp.Diff. Also use when a user asks to write a test for a Go function, even if they don't mention specific patterns like table-driven tests or subtests. Does not cover benchmark performance testing (see go-performance).
   0
   installs
8. ▌
   Go Generics · aneviaro bundle

   Use when deciding whether to use Go generics, writing generic functions or types, choosing constraints, or picking between type aliases and type definitions. Also use when a user is writing a utility function that could work with multiple types, even if they don't mention generics explicitly. Does not cover interface design without generics (see go-interfaces).
   0
   installs
9. ▌
   Go Packages · aneviaro bundle

   Use when creating Go packages, organizing imports, managing dependencies, or deciding how to structure Go code into packages. Also use when starting a new Go project or splitting a growing codebase into packages, even if the user doesn't explicitly ask about package organization. Does not cover naming individual identifiers (see go-naming).
   0
   installs
10. ▌
    Idea Honing · aneviaro

    Relentlessly interview the user to sharpen a vague idea into an actionable implementation spec, then save that spec to the repository. Use when the user wants to refine an idea, stress-test a concept, build a spec, write a PRD, or says "hone this idea", "grill me", "turn this into a spec", or similar.
    0
    installs
11. ▌
    Go Defensive · aneviaro bundle

    Use when hardening Go code at API boundaries — copying slices/maps, verifying interface compliance, using defer for cleanup, time.Time/time.Duration, or avoiding mutable globals. Also use when reviewing for robustness concerns like missing cleanup or unsafe crypto usage, even if the user doesn't mention "defensive programming." Does not cover error handling strategy (see go-error-handling).
    0
    installs
12. ▌
    Go Functions · aneviaro bundle

    Use when organizing functions within a Go file, formatting function signatures, designing return values, or following Printf-style naming conventions. Also use when a user is adding or refactoring any Go function, even if they don't mention function design or signature formatting. Does not cover functional options constructors (see go-functional-options).
    0
    installs
13. ▌
    Go Interfaces · aneviaro bundle

    Use when defining or implementing Go interfaces, designing abstractions, creating mockable boundaries for testing, or composing types through embedding. Also use when deciding whether to accept an interface or return a concrete type, or using type assertions or type switches, even if the user doesn't explicitly mention interfaces. Does not cover generics-based polymorphism (see go-generics).
    0
    installs
14. ▌
    Go Style Core · aneviaro bundle

    Use when working with Go formatting, line length, nesting, naked returns, semicolons, or core style principles. Also use when a style question isn't covered by a more specific skill, even if the user doesn't reference a specific style rule. Does not cover domain-specific patterns like error handling, naming, or testing (see specialized skills). Acts as fallback when no more specific style skill applies.
    0
    installs
15. ▌
    Writing Style · aneviaro

    Use for technical communication such as GitHub tickets, pull request descriptions and comments, code review comments, commit messages, and internal technical discussions. Be direct, brief, and natural. Do not use for README files, public documentation, blog posts, or public release notes.
    0
    installs
16. ▌
    Go Code Review · aneviaro bundle

    Use when reviewing Go code or checking code against community style standards. Also use proactively before submitting a Go PR or when reviewing any Go code changes, even if the user doesn't explicitly request a style review. Does not cover language-specific syntax — delegates to specialized skills.
    0
    installs
17. ▌
    Go Concurrency · aneviaro bundle

    Use when writing concurrent Go code — goroutines, channels, mutexes, or thread-safety guarantees. Also use when parallelizing work, fixing data races, or protecting shared state, even if the user doesn't explicitly mention concurrency primitives. Does not cover context.Context patterns (see go-context).
    0
    installs
18. ▌
    Go Performance · aneviaro bundle

    Use when optimizing Go code, investigating slow performance, or writing performance-critical sections. Also use when a user mentions slow Go code, string concatenation in loops, or asks about benchmarking, even if the user doesn't explicitly mention performance patterns. Does not cover concurrent performance patterns (see go-concurrency).
    0
    installs
19. ▌
    Implementation · aneviaro bundle

    Run a grounded implementation plan through guarded worker, revmux review, integration, and verification gates.
    0
    installs
20. ▌
    Go Control Flow · aneviaro bundle

    Use when writing conditionals, loops, or switch statements in Go — including if with initialization, early returns, for loop forms, range, switch, type switches, and blank identifier patterns. Also use when writing a simple if/else or for loop, even if the user doesn't mention guard clauses or variable scoping. Does not cover error flow patterns (see go-error-handling).
    0
    installs
21. ▌
    Go Declarations · aneviaro bundle

    Use when declaring or initializing Go variables, constants, structs, or maps — including var vs :=, reducing scope with if-init, formatting composite literals, designing iota enums, and using any instead of interface{}. Also use when writing a new struct or const block, even if the user doesn't ask about declaration style. Does not cover naming conventions (see go-naming).
    0
    installs
22. ▌
    Go Documentation · aneviaro bundle

    Use when writing or reviewing documentation for Go packages, types, functions, or methods. Also use proactively when creating new exported types, functions, or packages, even if the user doesn't explicitly ask about documentation. Does not cover code comments for non-exported symbols (see go-style-core).
    0
    installs
23. ▌
    Go Error Handling · aneviaro bundle

    Use when writing Go code that returns, wraps, or handles errors — choosing between sentinel errors, custom types, and fmt.Errorf (%w vs %v), structuring error flow, or deciding whether to log or return. Also use when propagating errors across package boundaries or using errors.Is/As, even if the user doesn't ask about error strategy. Does not cover panic/recover patterns (see go-defensive).
    0
    installs
24. ▌
    Go Data Structures · aneviaro bundle

    Use when working with Go slices, maps, or arrays — choosing between new and make, using append, declaring empty slices (nil vs literal for JSON), implementing sets with maps, and copying data at boundaries. Also use when building or manipulating collections, even if the user doesn't ask about allocation idioms. Does not cover concurrent data structure safety (see go-concurrency).
    0
    installs
25. ▌
    Plan Linked Review · aneviaro

    Review current local changes for correctness, quality, and best practices against a required implementation plan link or path. Use when asked to review local changes, diffs, or implementation progress against a plan/spec step. If no plan link/path is provided, use ask_user_question before reviewing.
    0
    installs
26. ▌
    Local Changes Review · aneviaro

    Review current uncommitted and untracked local changes for correctness, quality, best practices, and verification. Use when asked to review local changes, diffs, or implementation progress without a required implementation plan.
    0
    installs
27. ▌
    Go Functional Options · aneviaro bundle

    Use when designing a Go constructor or factory function with optional configuration — especially with 3+ optional parameters or extensible APIs. Also use when building a New* function that takes many settings, even if they don't mention "functional options" by name. Does not cover general function design (see go-functions).
    0
    installs
28. ▌
    Implementation Planning · aneviaro

    Turn an existing product/technical spec into a thorough, repository-grounded implementation plan. Use when asked to create an implementation plan, break a spec into tasks, make a Ralphex-compatible plan, or convert requirements into executable engineering steps.
    0
    installs
29. ▌
    Implementation Agent Contract · aneviaro

    Stable packet precedence, scope protection, and reporting rules for implementation workers.
    0
    installs